From 6220b444b4251bbfc74f9c216758e444ed133c99 Mon Sep 17 00:00:00 2001 From: Dreamer Date: Mon, 8 Jul 2024 17:22:11 +0800 Subject: [PATCH] add depinject for app module --- .../mt_transfer/module/v1/module.pulsar.go | 509 + .../apps/mt_transfer/v1/mt_transfer.pulsar.go | 1622 +++ api/tibc/apps/mt_transfer/v1/query.pulsar.go | 2250 ++++ api/tibc/apps/mt_transfer/v1/query_grpc.pb.go | 150 + api/tibc/apps/mt_transfer/v1/tx.pulsar.go | 1489 +++ api/tibc/apps/mt_transfer/v1/tx_grpc.pb.go | 111 + .../nft_transfer/module/v1/module.pulsar.go | 509 + .../nft_transfer/v1/nft_transfer.pulsar.go | 1565 +++ api/tibc/apps/nft_transfer/v1/query.pulsar.go | 2251 ++++ .../apps/nft_transfer/v1/query_grpc.pb.go | 150 + api/tibc/apps/nft_transfer/v1/tx.pulsar.go | 1432 ++ api/tibc/apps/nft_transfer/v1/tx_grpc.pb.go | 111 + api/tibc/core/client/v1/client.pulsar.go | 5404 ++++++++ api/tibc/core/client/v1/genesis.pulsar.go | 2376 ++++ api/tibc/core/client/v1/query.pulsar.go | 6015 +++++++++ api/tibc/core/client/v1/query_grpc.pb.go | 273 + api/tibc/core/client/v1/tx.pulsar.go | 4990 +++++++ api/tibc/core/client/v1/tx_grpc.pb.go | 228 + .../core/commitment/v1/commitment.pulsar.go | 2148 +++ api/tibc/core/packet/v1/genesis.pulsar.go | 2029 +++ api/tibc/core/packet/v1/packet.pulsar.go | 2956 +++++ api/tibc/core/packet/v1/query.pulsar.go | 10835 ++++++++++++++++ api/tibc/core/packet/v1/query_grpc.pb.go | 390 + api/tibc/core/packet/v1/tx.pulsar.go | 4586 +++++++ api/tibc/core/packet/v1/tx_grpc.pb.go | 228 + api/tibc/core/routing/v1/genesis.pulsar.go | 631 + api/tibc/core/routing/v1/query.pulsar.go | 1047 ++ api/tibc/core/routing/v1/query_grpc.pb.go | 111 + api/tibc/core/routing/v1/routing.pulsar.go | 785 ++ api/tibc/core/routing/v1/tx.pulsar.go | 1277 ++ api/tibc/core/routing/v1/tx_grpc.pb.go | 111 + api/tibc/core/types/v1/genesis.pulsar.go | 798 ++ api/tibc/lightclients/bsc/v1/bsc.pulsar.go | 6668 ++++++++++ api/tibc/lightclients/eth/v1/eth.pulsar.go | 4813 +++++++ .../tendermint/v1/tendermint.pulsar.go | 3344 +++++ modules/tibc/apps/mt_transfer/depinject.go | 69 + modules/tibc/apps/mt_transfer/handler.go | 2 +- .../tibc/apps/mt_transfer/keeper/keeper.go | 4 - modules/tibc/apps/mt_transfer/moudle.go | 2 +- .../tibc/apps/mt_transfer/transfer_test.go | 2 +- modules/tibc/apps/nft_transfer/depinject.go | 70 + modules/tibc/apps/nft_transfer/handler.go | 2 +- .../tibc/apps/nft_transfer/keeper/keeper.go | 4 - modules/tibc/apps/nft_transfer/moudle.go | 2 +- .../tibc/apps/nft_transfer/transfer_test.go | 2 +- modules/tibc/core/depinject.go | 30 +- .../apps/mt_transfer/module/v1/module.proto | 12 + .../apps/nft_transfer/module/v1/module.proto | 12 + simapp/app.go | 4 +- 49 files changed, 74387 insertions(+), 22 deletions(-) create mode 100644 api/tibc/apps/mt_transfer/module/v1/module.pulsar.go create mode 100644 api/tibc/apps/mt_transfer/v1/mt_transfer.pulsar.go create mode 100644 api/tibc/apps/mt_transfer/v1/query.pulsar.go create mode 100644 api/tibc/apps/mt_transfer/v1/query_grpc.pb.go create mode 100644 api/tibc/apps/mt_transfer/v1/tx.pulsar.go create mode 100644 api/tibc/apps/mt_transfer/v1/tx_grpc.pb.go create mode 100644 api/tibc/apps/nft_transfer/module/v1/module.pulsar.go create mode 100644 api/tibc/apps/nft_transfer/v1/nft_transfer.pulsar.go create mode 100644 api/tibc/apps/nft_transfer/v1/query.pulsar.go create mode 100644 api/tibc/apps/nft_transfer/v1/query_grpc.pb.go create mode 100644 api/tibc/apps/nft_transfer/v1/tx.pulsar.go create mode 100644 api/tibc/apps/nft_transfer/v1/tx_grpc.pb.go create mode 100644 api/tibc/core/client/v1/client.pulsar.go create mode 100644 api/tibc/core/client/v1/genesis.pulsar.go create mode 100644 api/tibc/core/client/v1/query.pulsar.go create mode 100644 api/tibc/core/client/v1/query_grpc.pb.go create mode 100644 api/tibc/core/client/v1/tx.pulsar.go create mode 100644 api/tibc/core/client/v1/tx_grpc.pb.go create mode 100644 api/tibc/core/commitment/v1/commitment.pulsar.go create mode 100644 api/tibc/core/packet/v1/genesis.pulsar.go create mode 100644 api/tibc/core/packet/v1/packet.pulsar.go create mode 100644 api/tibc/core/packet/v1/query.pulsar.go create mode 100644 api/tibc/core/packet/v1/query_grpc.pb.go create mode 100644 api/tibc/core/packet/v1/tx.pulsar.go create mode 100644 api/tibc/core/packet/v1/tx_grpc.pb.go create mode 100644 api/tibc/core/routing/v1/genesis.pulsar.go create mode 100644 api/tibc/core/routing/v1/query.pulsar.go create mode 100644 api/tibc/core/routing/v1/query_grpc.pb.go create mode 100644 api/tibc/core/routing/v1/routing.pulsar.go create mode 100644 api/tibc/core/routing/v1/tx.pulsar.go create mode 100644 api/tibc/core/routing/v1/tx_grpc.pb.go create mode 100644 api/tibc/core/types/v1/genesis.pulsar.go create mode 100644 api/tibc/lightclients/bsc/v1/bsc.pulsar.go create mode 100644 api/tibc/lightclients/eth/v1/eth.pulsar.go create mode 100644 api/tibc/lightclients/tendermint/v1/tendermint.pulsar.go create mode 100644 modules/tibc/apps/mt_transfer/depinject.go create mode 100644 modules/tibc/apps/nft_transfer/depinject.go create mode 100644 proto/tibc/apps/mt_transfer/module/v1/module.proto create mode 100644 proto/tibc/apps/nft_transfer/module/v1/module.proto diff --git a/api/tibc/apps/mt_transfer/module/v1/module.pulsar.go b/api/tibc/apps/mt_transfer/module/v1/module.pulsar.go new file mode 100644 index 00000000..16423f0b --- /dev/null +++ b/api/tibc/apps/mt_transfer/module/v1/module.pulsar.go @@ -0,0 +1,509 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package modulev1 + +import ( + _ "cosmossdk.io/api/cosmos/app/v1alpha1" + fmt "fmt" + runtime "github.com/cosmos/cosmos-proto/runtime" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoiface "google.golang.org/protobuf/runtime/protoiface" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_Module protoreflect.MessageDescriptor +) + +func init() { + file_tibc_apps_mt_transfer_module_v1_module_proto_init() + md_Module = File_tibc_apps_mt_transfer_module_v1_module_proto.Messages().ByName("Module") +} + +var _ protoreflect.Message = (*fastReflection_Module)(nil) + +type fastReflection_Module Module + +func (x *Module) ProtoReflect() protoreflect.Message { + return (*fastReflection_Module)(x) +} + +func (x *Module) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_apps_mt_transfer_module_v1_module_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_Module_messageType fastReflection_Module_messageType +var _ protoreflect.MessageType = fastReflection_Module_messageType{} + +type fastReflection_Module_messageType struct{} + +func (x fastReflection_Module_messageType) Zero() protoreflect.Message { + return (*fastReflection_Module)(nil) +} +func (x fastReflection_Module_messageType) New() protoreflect.Message { + return new(fastReflection_Module) +} +func (x fastReflection_Module_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Module +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Module) Descriptor() protoreflect.MessageDescriptor { + return md_Module +} + +// 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_Module) Type() protoreflect.MessageType { + return _fastReflection_Module_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Module) New() protoreflect.Message { + return new(fastReflection_Module) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Module) Interface() protoreflect.ProtoMessage { + return (*Module)(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_Module) 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_Module) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.module.v1.Module")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.module.v1.Module 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_Module) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.module.v1.Module")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.module.v1.Module 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_Module) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.module.v1.Module")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.module.v1.Module 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_Module) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.module.v1.Module")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.module.v1.Module 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_Module) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.module.v1.Module")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.module.v1.Module 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_Module) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.module.v1.Module")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.module.v1.Module 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_Module) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.apps.mt_transfer.module.v1.Module", 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_Module) 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_Module) 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_Module) 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_Module) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Module) + 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().(*Module) + 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().(*Module) + 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: Module: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Module: 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, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: tibc/apps/mt_transfer/module/v1/module.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) +) + +// Module is the config object of the tibc module. +type Module struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *Module) Reset() { + *x = Module{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_apps_mt_transfer_module_v1_module_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Module) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Module) ProtoMessage() {} + +// Deprecated: Use Module.ProtoReflect.Descriptor instead. +func (*Module) Descriptor() ([]byte, []int) { + return file_tibc_apps_mt_transfer_module_v1_module_proto_rawDescGZIP(), []int{0} +} + +var File_tibc_apps_mt_transfer_module_v1_module_proto protoreflect.FileDescriptor + +var file_tibc_apps_mt_transfer_module_v1_module_proto_rawDesc = []byte{ + 0x0a, 0x2c, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x61, 0x70, 0x70, 0x73, 0x2f, 0x6d, 0x74, 0x5f, 0x74, + 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2f, 0x76, + 0x31, 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1f, + 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, + 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x1a, + 0x20, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x61, 0x70, 0x70, 0x2f, 0x76, 0x31, 0x61, 0x6c, + 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x22, 0x4c, 0x0a, 0x06, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x3a, 0x42, 0xba, 0xc0, 0x96, + 0xda, 0x01, 0x3c, 0x0a, 0x3a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, + 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2d, 0x67, + 0x6f, 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x73, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x61, + 0x70, 0x70, 0x73, 0x2f, 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x42, + 0x9a, 0x02, 0x0a, 0x23, 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, + 0x73, 0x2e, 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x6d, 0x6f, + 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x42, 0x0b, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x49, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, + 0x63, 0x2d, 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x61, 0x70, + 0x70, 0x73, 0x2f, 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x6d, + 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2f, 0x76, 0x31, 0x3b, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x76, + 0x31, 0xa2, 0x02, 0x04, 0x54, 0x41, 0x4d, 0x4d, 0xaa, 0x02, 0x1e, 0x54, 0x69, 0x62, 0x63, 0x2e, + 0x41, 0x70, 0x70, 0x73, 0x2e, 0x4d, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, + 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x1e, 0x54, 0x69, 0x62, 0x63, + 0x5c, 0x41, 0x70, 0x70, 0x73, 0x5c, 0x4d, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, + 0x5c, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x2a, 0x54, 0x69, 0x62, + 0x63, 0x5c, 0x41, 0x70, 0x70, 0x73, 0x5c, 0x4d, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, + 0x72, 0x5c, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x22, 0x54, 0x69, 0x62, 0x63, 0x3a, 0x3a, + 0x41, 0x70, 0x70, 0x73, 0x3a, 0x3a, 0x4d, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, + 0x3a, 0x3a, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_apps_mt_transfer_module_v1_module_proto_rawDescOnce sync.Once + file_tibc_apps_mt_transfer_module_v1_module_proto_rawDescData = file_tibc_apps_mt_transfer_module_v1_module_proto_rawDesc +) + +func file_tibc_apps_mt_transfer_module_v1_module_proto_rawDescGZIP() []byte { + file_tibc_apps_mt_transfer_module_v1_module_proto_rawDescOnce.Do(func() { + file_tibc_apps_mt_transfer_module_v1_module_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_apps_mt_transfer_module_v1_module_proto_rawDescData) + }) + return file_tibc_apps_mt_transfer_module_v1_module_proto_rawDescData +} + +var file_tibc_apps_mt_transfer_module_v1_module_proto_msgTypes = make([]protoimpl.MessageInfo, 1) +var file_tibc_apps_mt_transfer_module_v1_module_proto_goTypes = []interface{}{ + (*Module)(nil), // 0: tibc.apps.mt_transfer.module.v1.Module +} +var file_tibc_apps_mt_transfer_module_v1_module_proto_depIdxs = []int32{ + 0, // [0:0] is the sub-list for method output_type + 0, // [0:0] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_tibc_apps_mt_transfer_module_v1_module_proto_init() } +func file_tibc_apps_mt_transfer_module_v1_module_proto_init() { + if File_tibc_apps_mt_transfer_module_v1_module_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_tibc_apps_mt_transfer_module_v1_module_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Module); 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_tibc_apps_mt_transfer_module_v1_module_proto_rawDesc, + NumEnums: 0, + NumMessages: 1, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_tibc_apps_mt_transfer_module_v1_module_proto_goTypes, + DependencyIndexes: file_tibc_apps_mt_transfer_module_v1_module_proto_depIdxs, + MessageInfos: file_tibc_apps_mt_transfer_module_v1_module_proto_msgTypes, + }.Build() + File_tibc_apps_mt_transfer_module_v1_module_proto = out.File + file_tibc_apps_mt_transfer_module_v1_module_proto_rawDesc = nil + file_tibc_apps_mt_transfer_module_v1_module_proto_goTypes = nil + file_tibc_apps_mt_transfer_module_v1_module_proto_depIdxs = nil +} diff --git a/api/tibc/apps/mt_transfer/v1/mt_transfer.pulsar.go b/api/tibc/apps/mt_transfer/v1/mt_transfer.pulsar.go new file mode 100644 index 00000000..298c07ad --- /dev/null +++ b/api/tibc/apps/mt_transfer/v1/mt_transfer.pulsar.go @@ -0,0 +1,1622 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package mt_transferv1 + +import ( + fmt "fmt" + runtime "github.com/cosmos/cosmos-proto/runtime" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoiface "google.golang.org/protobuf/runtime/protoiface" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_MultiTokenPacketData protoreflect.MessageDescriptor + fd_MultiTokenPacketData_class protoreflect.FieldDescriptor + fd_MultiTokenPacketData_id protoreflect.FieldDescriptor + fd_MultiTokenPacketData_data protoreflect.FieldDescriptor + fd_MultiTokenPacketData_sender protoreflect.FieldDescriptor + fd_MultiTokenPacketData_receiver protoreflect.FieldDescriptor + fd_MultiTokenPacketData_away_from_origin protoreflect.FieldDescriptor + fd_MultiTokenPacketData_dest_contract protoreflect.FieldDescriptor + fd_MultiTokenPacketData_amount protoreflect.FieldDescriptor +) + +func init() { + file_tibc_apps_mt_transfer_v1_mt_transfer_proto_init() + md_MultiTokenPacketData = File_tibc_apps_mt_transfer_v1_mt_transfer_proto.Messages().ByName("MultiTokenPacketData") + fd_MultiTokenPacketData_class = md_MultiTokenPacketData.Fields().ByName("class") + fd_MultiTokenPacketData_id = md_MultiTokenPacketData.Fields().ByName("id") + fd_MultiTokenPacketData_data = md_MultiTokenPacketData.Fields().ByName("data") + fd_MultiTokenPacketData_sender = md_MultiTokenPacketData.Fields().ByName("sender") + fd_MultiTokenPacketData_receiver = md_MultiTokenPacketData.Fields().ByName("receiver") + fd_MultiTokenPacketData_away_from_origin = md_MultiTokenPacketData.Fields().ByName("away_from_origin") + fd_MultiTokenPacketData_dest_contract = md_MultiTokenPacketData.Fields().ByName("dest_contract") + fd_MultiTokenPacketData_amount = md_MultiTokenPacketData.Fields().ByName("amount") +} + +var _ protoreflect.Message = (*fastReflection_MultiTokenPacketData)(nil) + +type fastReflection_MultiTokenPacketData MultiTokenPacketData + +func (x *MultiTokenPacketData) ProtoReflect() protoreflect.Message { + return (*fastReflection_MultiTokenPacketData)(x) +} + +func (x *MultiTokenPacketData) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_apps_mt_transfer_v1_mt_transfer_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_MultiTokenPacketData_messageType fastReflection_MultiTokenPacketData_messageType +var _ protoreflect.MessageType = fastReflection_MultiTokenPacketData_messageType{} + +type fastReflection_MultiTokenPacketData_messageType struct{} + +func (x fastReflection_MultiTokenPacketData_messageType) Zero() protoreflect.Message { + return (*fastReflection_MultiTokenPacketData)(nil) +} +func (x fastReflection_MultiTokenPacketData_messageType) New() protoreflect.Message { + return new(fastReflection_MultiTokenPacketData) +} +func (x fastReflection_MultiTokenPacketData_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MultiTokenPacketData +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MultiTokenPacketData) Descriptor() protoreflect.MessageDescriptor { + return md_MultiTokenPacketData +} + +// 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_MultiTokenPacketData) Type() protoreflect.MessageType { + return _fastReflection_MultiTokenPacketData_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MultiTokenPacketData) New() protoreflect.Message { + return new(fastReflection_MultiTokenPacketData) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MultiTokenPacketData) Interface() protoreflect.ProtoMessage { + return (*MultiTokenPacketData)(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_MultiTokenPacketData) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Class != "" { + value := protoreflect.ValueOfString(x.Class) + if !f(fd_MultiTokenPacketData_class, value) { + return + } + } + if x.Id != "" { + value := protoreflect.ValueOfString(x.Id) + if !f(fd_MultiTokenPacketData_id, value) { + return + } + } + if len(x.Data) != 0 { + value := protoreflect.ValueOfBytes(x.Data) + if !f(fd_MultiTokenPacketData_data, value) { + return + } + } + if x.Sender != "" { + value := protoreflect.ValueOfString(x.Sender) + if !f(fd_MultiTokenPacketData_sender, value) { + return + } + } + if x.Receiver != "" { + value := protoreflect.ValueOfString(x.Receiver) + if !f(fd_MultiTokenPacketData_receiver, value) { + return + } + } + if x.AwayFromOrigin != false { + value := protoreflect.ValueOfBool(x.AwayFromOrigin) + if !f(fd_MultiTokenPacketData_away_from_origin, value) { + return + } + } + if x.DestContract != "" { + value := protoreflect.ValueOfString(x.DestContract) + if !f(fd_MultiTokenPacketData_dest_contract, value) { + return + } + } + if x.Amount != uint64(0) { + value := protoreflect.ValueOfUint64(x.Amount) + if !f(fd_MultiTokenPacketData_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_MultiTokenPacketData) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.class": + return x.Class != "" + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.id": + return x.Id != "" + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.data": + return len(x.Data) != 0 + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.sender": + return x.Sender != "" + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.receiver": + return x.Receiver != "" + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.away_from_origin": + return x.AwayFromOrigin != false + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.dest_contract": + return x.DestContract != "" + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.amount": + return x.Amount != uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.MultiTokenPacketData")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.MultiTokenPacketData 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_MultiTokenPacketData) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.class": + x.Class = "" + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.id": + x.Id = "" + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.data": + x.Data = nil + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.sender": + x.Sender = "" + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.receiver": + x.Receiver = "" + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.away_from_origin": + x.AwayFromOrigin = false + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.dest_contract": + x.DestContract = "" + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.amount": + x.Amount = uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.MultiTokenPacketData")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.MultiTokenPacketData 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_MultiTokenPacketData) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.class": + value := x.Class + return protoreflect.ValueOfString(value) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.id": + value := x.Id + return protoreflect.ValueOfString(value) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.data": + value := x.Data + return protoreflect.ValueOfBytes(value) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.sender": + value := x.Sender + return protoreflect.ValueOfString(value) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.receiver": + value := x.Receiver + return protoreflect.ValueOfString(value) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.away_from_origin": + value := x.AwayFromOrigin + return protoreflect.ValueOfBool(value) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.dest_contract": + value := x.DestContract + return protoreflect.ValueOfString(value) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.amount": + value := x.Amount + return protoreflect.ValueOfUint64(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.MultiTokenPacketData")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.MultiTokenPacketData 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_MultiTokenPacketData) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.class": + x.Class = value.Interface().(string) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.id": + x.Id = value.Interface().(string) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.data": + x.Data = value.Bytes() + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.sender": + x.Sender = value.Interface().(string) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.receiver": + x.Receiver = value.Interface().(string) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.away_from_origin": + x.AwayFromOrigin = value.Bool() + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.dest_contract": + x.DestContract = value.Interface().(string) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.amount": + x.Amount = value.Uint() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.MultiTokenPacketData")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.MultiTokenPacketData 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_MultiTokenPacketData) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.class": + panic(fmt.Errorf("field class of message tibc.apps.mt_transfer.v1.MultiTokenPacketData is not mutable")) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.id": + panic(fmt.Errorf("field id of message tibc.apps.mt_transfer.v1.MultiTokenPacketData is not mutable")) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.data": + panic(fmt.Errorf("field data of message tibc.apps.mt_transfer.v1.MultiTokenPacketData is not mutable")) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.sender": + panic(fmt.Errorf("field sender of message tibc.apps.mt_transfer.v1.MultiTokenPacketData is not mutable")) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.receiver": + panic(fmt.Errorf("field receiver of message tibc.apps.mt_transfer.v1.MultiTokenPacketData is not mutable")) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.away_from_origin": + panic(fmt.Errorf("field away_from_origin of message tibc.apps.mt_transfer.v1.MultiTokenPacketData is not mutable")) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.dest_contract": + panic(fmt.Errorf("field dest_contract of message tibc.apps.mt_transfer.v1.MultiTokenPacketData is not mutable")) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.amount": + panic(fmt.Errorf("field amount of message tibc.apps.mt_transfer.v1.MultiTokenPacketData is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.MultiTokenPacketData")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.MultiTokenPacketData 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_MultiTokenPacketData) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.class": + return protoreflect.ValueOfString("") + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.id": + return protoreflect.ValueOfString("") + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.data": + return protoreflect.ValueOfBytes(nil) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.sender": + return protoreflect.ValueOfString("") + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.receiver": + return protoreflect.ValueOfString("") + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.away_from_origin": + return protoreflect.ValueOfBool(false) + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.dest_contract": + return protoreflect.ValueOfString("") + case "tibc.apps.mt_transfer.v1.MultiTokenPacketData.amount": + return protoreflect.ValueOfUint64(uint64(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.MultiTokenPacketData")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.MultiTokenPacketData 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_MultiTokenPacketData) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.apps.mt_transfer.v1.MultiTokenPacketData", 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_MultiTokenPacketData) 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_MultiTokenPacketData) 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_MultiTokenPacketData) 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_MultiTokenPacketData) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MultiTokenPacketData) + 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.Class) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Id) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Data) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Sender) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Receiver) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.AwayFromOrigin { + n += 2 + } + l = len(x.DestContract) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Amount != 0 { + n += 1 + runtime.Sov(uint64(x.Amount)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*MultiTokenPacketData) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Amount != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Amount)) + i-- + dAtA[i] = 0x40 + } + if len(x.DestContract) > 0 { + i -= len(x.DestContract) + copy(dAtA[i:], x.DestContract) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestContract))) + i-- + dAtA[i] = 0x3a + } + if x.AwayFromOrigin { + i-- + if x.AwayFromOrigin { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x30 + } + if len(x.Receiver) > 0 { + i -= len(x.Receiver) + copy(dAtA[i:], x.Receiver) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Receiver))) + i-- + dAtA[i] = 0x2a + } + if len(x.Sender) > 0 { + i -= len(x.Sender) + copy(dAtA[i:], x.Sender) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Sender))) + i-- + dAtA[i] = 0x22 + } + if len(x.Data) > 0 { + i -= len(x.Data) + copy(dAtA[i:], x.Data) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Data))) + i-- + dAtA[i] = 0x1a + } + if len(x.Id) > 0 { + i -= len(x.Id) + copy(dAtA[i:], x.Id) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id))) + i-- + dAtA[i] = 0x12 + } + if len(x.Class) > 0 { + i -= len(x.Class) + copy(dAtA[i:], x.Class) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Class))) + 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().(*MultiTokenPacketData) + 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: MultiTokenPacketData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MultiTokenPacketData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Class", wireType) + } + var 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.Class = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Data = append(x.Data[:0], dAtA[iNdEx:postIndex]...) + if x.Data == nil { + x.Data = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Receiver", 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.Receiver = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field AwayFromOrigin", wireType) + } + var v 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++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.AwayFromOrigin = bool(v != 0) + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DestContract", 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.DestContract = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + x.Amount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Amount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_ClassTrace protoreflect.MessageDescriptor + fd_ClassTrace_path protoreflect.FieldDescriptor + fd_ClassTrace_base_class protoreflect.FieldDescriptor +) + +func init() { + file_tibc_apps_mt_transfer_v1_mt_transfer_proto_init() + md_ClassTrace = File_tibc_apps_mt_transfer_v1_mt_transfer_proto.Messages().ByName("ClassTrace") + fd_ClassTrace_path = md_ClassTrace.Fields().ByName("path") + fd_ClassTrace_base_class = md_ClassTrace.Fields().ByName("base_class") +} + +var _ protoreflect.Message = (*fastReflection_ClassTrace)(nil) + +type fastReflection_ClassTrace ClassTrace + +func (x *ClassTrace) ProtoReflect() protoreflect.Message { + return (*fastReflection_ClassTrace)(x) +} + +func (x *ClassTrace) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_apps_mt_transfer_v1_mt_transfer_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_ClassTrace_messageType fastReflection_ClassTrace_messageType +var _ protoreflect.MessageType = fastReflection_ClassTrace_messageType{} + +type fastReflection_ClassTrace_messageType struct{} + +func (x fastReflection_ClassTrace_messageType) Zero() protoreflect.Message { + return (*fastReflection_ClassTrace)(nil) +} +func (x fastReflection_ClassTrace_messageType) New() protoreflect.Message { + return new(fastReflection_ClassTrace) +} +func (x fastReflection_ClassTrace_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_ClassTrace +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_ClassTrace) Descriptor() protoreflect.MessageDescriptor { + return md_ClassTrace +} + +// 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_ClassTrace) Type() protoreflect.MessageType { + return _fastReflection_ClassTrace_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_ClassTrace) New() protoreflect.Message { + return new(fastReflection_ClassTrace) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_ClassTrace) Interface() protoreflect.ProtoMessage { + return (*ClassTrace)(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_ClassTrace) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Path != "" { + value := protoreflect.ValueOfString(x.Path) + if !f(fd_ClassTrace_path, value) { + return + } + } + if x.BaseClass != "" { + value := protoreflect.ValueOfString(x.BaseClass) + if !f(fd_ClassTrace_base_class, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_ClassTrace) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.ClassTrace.path": + return x.Path != "" + case "tibc.apps.mt_transfer.v1.ClassTrace.base_class": + return x.BaseClass != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.ClassTrace")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.ClassTrace 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_ClassTrace) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.ClassTrace.path": + x.Path = "" + case "tibc.apps.mt_transfer.v1.ClassTrace.base_class": + x.BaseClass = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.ClassTrace")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.ClassTrace 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_ClassTrace) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.apps.mt_transfer.v1.ClassTrace.path": + value := x.Path + return protoreflect.ValueOfString(value) + case "tibc.apps.mt_transfer.v1.ClassTrace.base_class": + value := x.BaseClass + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.ClassTrace")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.ClassTrace 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_ClassTrace) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.ClassTrace.path": + x.Path = value.Interface().(string) + case "tibc.apps.mt_transfer.v1.ClassTrace.base_class": + x.BaseClass = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.ClassTrace")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.ClassTrace 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_ClassTrace) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.ClassTrace.path": + panic(fmt.Errorf("field path of message tibc.apps.mt_transfer.v1.ClassTrace is not mutable")) + case "tibc.apps.mt_transfer.v1.ClassTrace.base_class": + panic(fmt.Errorf("field base_class of message tibc.apps.mt_transfer.v1.ClassTrace is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.ClassTrace")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.ClassTrace 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_ClassTrace) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.ClassTrace.path": + return protoreflect.ValueOfString("") + case "tibc.apps.mt_transfer.v1.ClassTrace.base_class": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.ClassTrace")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.ClassTrace 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_ClassTrace) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.apps.mt_transfer.v1.ClassTrace", 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_ClassTrace) 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_ClassTrace) 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_ClassTrace) 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_ClassTrace) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*ClassTrace) + 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.Path) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.BaseClass) + 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().(*ClassTrace) + 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.BaseClass) > 0 { + i -= len(x.BaseClass) + copy(dAtA[i:], x.BaseClass) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.BaseClass))) + i-- + dAtA[i] = 0x12 + } + if len(x.Path) > 0 { + i -= len(x.Path) + copy(dAtA[i:], x.Path) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Path))) + 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().(*ClassTrace) + 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: ClassTrace: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ClassTrace: 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 Path", 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.Path = 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 BaseClass", 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.BaseClass = 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, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: tibc/apps/mt_transfer/v1/mt_transfer.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) +) + +type MultiTokenPacketData struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // the class to which the Mt to be transferred belongs + Class string `protobuf:"bytes,1,opt,name=class,proto3" json:"class,omitempty"` + // the mt id + Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` + // the address defined by MT outside the chain + Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` + // the mt sender + Sender string `protobuf:"bytes,4,opt,name=sender,proto3" json:"sender,omitempty"` + // the mt receiver + Receiver string `protobuf:"bytes,5,opt,name=receiver,proto3" json:"receiver,omitempty"` + // identify whether it is far away from the source chain + AwayFromOrigin bool `protobuf:"varint,6,opt,name=away_from_origin,json=awayFromOrigin,proto3" json:"away_from_origin,omitempty"` + // the destination contract address to receive the nft + DestContract string `protobuf:"bytes,7,opt,name=dest_contract,json=destContract,proto3" json:"dest_contract,omitempty"` + // the amount defined by MT outside the chain + Amount uint64 `protobuf:"varint,8,opt,name=amount,proto3" json:"amount,omitempty"` +} + +func (x *MultiTokenPacketData) Reset() { + *x = MultiTokenPacketData{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_apps_mt_transfer_v1_mt_transfer_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MultiTokenPacketData) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MultiTokenPacketData) ProtoMessage() {} + +// Deprecated: Use MultiTokenPacketData.ProtoReflect.Descriptor instead. +func (*MultiTokenPacketData) Descriptor() ([]byte, []int) { + return file_tibc_apps_mt_transfer_v1_mt_transfer_proto_rawDescGZIP(), []int{0} +} + +func (x *MultiTokenPacketData) GetClass() string { + if x != nil { + return x.Class + } + return "" +} + +func (x *MultiTokenPacketData) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *MultiTokenPacketData) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *MultiTokenPacketData) GetSender() string { + if x != nil { + return x.Sender + } + return "" +} + +func (x *MultiTokenPacketData) GetReceiver() string { + if x != nil { + return x.Receiver + } + return "" +} + +func (x *MultiTokenPacketData) GetAwayFromOrigin() bool { + if x != nil { + return x.AwayFromOrigin + } + return false +} + +func (x *MultiTokenPacketData) GetDestContract() string { + if x != nil { + return x.DestContract + } + return "" +} + +func (x *MultiTokenPacketData) GetAmount() uint64 { + if x != nil { + return x.Amount + } + return 0 +} + +// ClassTrace contains the base class for Multi Token and the +// source tracing information path. +type ClassTrace struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // path defines the chain of sourceChain/destChain + // identifiers used for tracing the source of the Non fungible token. + Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` + // base class of the relayed non fungible token. + BaseClass string `protobuf:"bytes,2,opt,name=base_class,json=baseClass,proto3" json:"base_class,omitempty"` +} + +func (x *ClassTrace) Reset() { + *x = ClassTrace{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_apps_mt_transfer_v1_mt_transfer_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ClassTrace) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ClassTrace) ProtoMessage() {} + +// Deprecated: Use ClassTrace.ProtoReflect.Descriptor instead. +func (*ClassTrace) Descriptor() ([]byte, []int) { + return file_tibc_apps_mt_transfer_v1_mt_transfer_proto_rawDescGZIP(), []int{1} +} + +func (x *ClassTrace) GetPath() string { + if x != nil { + return x.Path + } + return "" +} + +func (x *ClassTrace) GetBaseClass() string { + if x != nil { + return x.BaseClass + } + return "" +} + +var File_tibc_apps_mt_transfer_v1_mt_transfer_proto protoreflect.FileDescriptor + +var file_tibc_apps_mt_transfer_v1_mt_transfer_proto_rawDesc = []byte{ + 0x0a, 0x2a, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x61, 0x70, 0x70, 0x73, 0x2f, 0x6d, 0x74, 0x5f, 0x74, + 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x74, 0x5f, 0x74, 0x72, + 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x18, 0x74, 0x69, + 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, + 0x66, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x22, 0xeb, 0x01, 0x0a, 0x14, 0x4d, 0x75, 0x6c, 0x74, 0x69, + 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, + 0x14, 0x0a, 0x05, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x63, 0x6c, 0x61, 0x73, 0x73, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x65, 0x6e, + 0x64, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, + 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x08, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x12, 0x28, 0x0a, + 0x10, 0x61, 0x77, 0x61, 0x79, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x6f, 0x72, 0x69, 0x67, 0x69, + 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x61, 0x77, 0x61, 0x79, 0x46, 0x72, 0x6f, + 0x6d, 0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x64, 0x65, 0x73, 0x74, 0x5f, + 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, + 0x64, 0x65, 0x73, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x12, 0x16, 0x0a, 0x06, + 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, + 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3f, 0x0a, 0x0a, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, + 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x63, + 0x6c, 0x61, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x62, 0x61, 0x73, 0x65, + 0x43, 0x6c, 0x61, 0x73, 0x73, 0x42, 0xf7, 0x01, 0x0a, 0x1c, 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x69, + 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, + 0x66, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x42, 0x0f, 0x4d, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, + 0x65, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x47, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, 0x2f, + 0x74, 0x69, 0x62, 0x63, 0x2d, 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, + 0x2f, 0x61, 0x70, 0x70, 0x73, 0x2f, 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, + 0x72, 0x2f, 0x76, 0x31, 0x3b, 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, + 0x76, 0x31, 0xa2, 0x02, 0x03, 0x54, 0x41, 0x4d, 0xaa, 0x02, 0x17, 0x54, 0x69, 0x62, 0x63, 0x2e, + 0x41, 0x70, 0x70, 0x73, 0x2e, 0x4d, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, + 0x56, 0x31, 0xca, 0x02, 0x17, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x41, 0x70, 0x70, 0x73, 0x5c, 0x4d, + 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x23, 0x54, + 0x69, 0x62, 0x63, 0x5c, 0x41, 0x70, 0x70, 0x73, 0x5c, 0x4d, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, + 0x66, 0x65, 0x72, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x1a, 0x54, 0x69, 0x62, 0x63, 0x3a, 0x3a, 0x41, 0x70, 0x70, 0x73, 0x3a, + 0x3a, 0x4d, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x3a, 0x3a, 0x56, 0x31, 0x62, + 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_apps_mt_transfer_v1_mt_transfer_proto_rawDescOnce sync.Once + file_tibc_apps_mt_transfer_v1_mt_transfer_proto_rawDescData = file_tibc_apps_mt_transfer_v1_mt_transfer_proto_rawDesc +) + +func file_tibc_apps_mt_transfer_v1_mt_transfer_proto_rawDescGZIP() []byte { + file_tibc_apps_mt_transfer_v1_mt_transfer_proto_rawDescOnce.Do(func() { + file_tibc_apps_mt_transfer_v1_mt_transfer_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_apps_mt_transfer_v1_mt_transfer_proto_rawDescData) + }) + return file_tibc_apps_mt_transfer_v1_mt_transfer_proto_rawDescData +} + +var file_tibc_apps_mt_transfer_v1_mt_transfer_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_tibc_apps_mt_transfer_v1_mt_transfer_proto_goTypes = []interface{}{ + (*MultiTokenPacketData)(nil), // 0: tibc.apps.mt_transfer.v1.MultiTokenPacketData + (*ClassTrace)(nil), // 1: tibc.apps.mt_transfer.v1.ClassTrace +} +var file_tibc_apps_mt_transfer_v1_mt_transfer_proto_depIdxs = []int32{ + 0, // [0:0] is the sub-list for method output_type + 0, // [0:0] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_tibc_apps_mt_transfer_v1_mt_transfer_proto_init() } +func file_tibc_apps_mt_transfer_v1_mt_transfer_proto_init() { + if File_tibc_apps_mt_transfer_v1_mt_transfer_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_tibc_apps_mt_transfer_v1_mt_transfer_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MultiTokenPacketData); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_apps_mt_transfer_v1_mt_transfer_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ClassTrace); 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_tibc_apps_mt_transfer_v1_mt_transfer_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_tibc_apps_mt_transfer_v1_mt_transfer_proto_goTypes, + DependencyIndexes: file_tibc_apps_mt_transfer_v1_mt_transfer_proto_depIdxs, + MessageInfos: file_tibc_apps_mt_transfer_v1_mt_transfer_proto_msgTypes, + }.Build() + File_tibc_apps_mt_transfer_v1_mt_transfer_proto = out.File + file_tibc_apps_mt_transfer_v1_mt_transfer_proto_rawDesc = nil + file_tibc_apps_mt_transfer_v1_mt_transfer_proto_goTypes = nil + file_tibc_apps_mt_transfer_v1_mt_transfer_proto_depIdxs = nil +} diff --git a/api/tibc/apps/mt_transfer/v1/query.pulsar.go b/api/tibc/apps/mt_transfer/v1/query.pulsar.go new file mode 100644 index 00000000..4e0aaf82 --- /dev/null +++ b/api/tibc/apps/mt_transfer/v1/query.pulsar.go @@ -0,0 +1,2250 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package mt_transferv1 + +import ( + v1beta1 "cosmossdk.io/api/cosmos/base/query/v1beta1" + fmt "fmt" + runtime "github.com/cosmos/cosmos-proto/runtime" + _ "github.com/cosmos/gogoproto/gogoproto" + _ "google.golang.org/genproto/googleapis/api/annotations" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoiface "google.golang.org/protobuf/runtime/protoiface" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_QueryClassTraceRequest protoreflect.MessageDescriptor + fd_QueryClassTraceRequest_hash protoreflect.FieldDescriptor +) + +func init() { + file_tibc_apps_mt_transfer_v1_query_proto_init() + md_QueryClassTraceRequest = File_tibc_apps_mt_transfer_v1_query_proto.Messages().ByName("QueryClassTraceRequest") + fd_QueryClassTraceRequest_hash = md_QueryClassTraceRequest.Fields().ByName("hash") +} + +var _ protoreflect.Message = (*fastReflection_QueryClassTraceRequest)(nil) + +type fastReflection_QueryClassTraceRequest QueryClassTraceRequest + +func (x *QueryClassTraceRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryClassTraceRequest)(x) +} + +func (x *QueryClassTraceRequest) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_apps_mt_transfer_v1_query_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryClassTraceRequest_messageType fastReflection_QueryClassTraceRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryClassTraceRequest_messageType{} + +type fastReflection_QueryClassTraceRequest_messageType struct{} + +func (x fastReflection_QueryClassTraceRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryClassTraceRequest)(nil) +} +func (x fastReflection_QueryClassTraceRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryClassTraceRequest) +} +func (x fastReflection_QueryClassTraceRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClassTraceRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryClassTraceRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClassTraceRequest +} + +// 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_QueryClassTraceRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryClassTraceRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryClassTraceRequest) New() protoreflect.Message { + return new(fastReflection_QueryClassTraceRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryClassTraceRequest) Interface() protoreflect.ProtoMessage { + return (*QueryClassTraceRequest)(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_QueryClassTraceRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Hash != "" { + value := protoreflect.ValueOfString(x.Hash) + if !f(fd_QueryClassTraceRequest_hash, 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_QueryClassTraceRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTraceRequest.hash": + return x.Hash != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTraceRequest")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTraceRequest 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_QueryClassTraceRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTraceRequest.hash": + x.Hash = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTraceRequest")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTraceRequest 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_QueryClassTraceRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTraceRequest.hash": + value := x.Hash + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTraceRequest")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTraceRequest 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_QueryClassTraceRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTraceRequest.hash": + x.Hash = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTraceRequest")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTraceRequest 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_QueryClassTraceRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTraceRequest.hash": + panic(fmt.Errorf("field hash of message tibc.apps.mt_transfer.v1.QueryClassTraceRequest is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTraceRequest")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTraceRequest 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_QueryClassTraceRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTraceRequest.hash": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTraceRequest")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTraceRequest 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_QueryClassTraceRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.apps.mt_transfer.v1.QueryClassTraceRequest", 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_QueryClassTraceRequest) 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_QueryClassTraceRequest) 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_QueryClassTraceRequest) 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_QueryClassTraceRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryClassTraceRequest) + 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.Hash) + 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().(*QueryClassTraceRequest) + 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.Hash) > 0 { + i -= len(x.Hash) + copy(dAtA[i:], x.Hash) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Hash))) + 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().(*QueryClassTraceRequest) + 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: QueryClassTraceRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryClassTraceRequest: 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 Hash", 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.Hash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_QueryClassTraceResponse protoreflect.MessageDescriptor + fd_QueryClassTraceResponse_class_trace protoreflect.FieldDescriptor +) + +func init() { + file_tibc_apps_mt_transfer_v1_query_proto_init() + md_QueryClassTraceResponse = File_tibc_apps_mt_transfer_v1_query_proto.Messages().ByName("QueryClassTraceResponse") + fd_QueryClassTraceResponse_class_trace = md_QueryClassTraceResponse.Fields().ByName("class_trace") +} + +var _ protoreflect.Message = (*fastReflection_QueryClassTraceResponse)(nil) + +type fastReflection_QueryClassTraceResponse QueryClassTraceResponse + +func (x *QueryClassTraceResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryClassTraceResponse)(x) +} + +func (x *QueryClassTraceResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_apps_mt_transfer_v1_query_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryClassTraceResponse_messageType fastReflection_QueryClassTraceResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryClassTraceResponse_messageType{} + +type fastReflection_QueryClassTraceResponse_messageType struct{} + +func (x fastReflection_QueryClassTraceResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryClassTraceResponse)(nil) +} +func (x fastReflection_QueryClassTraceResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryClassTraceResponse) +} +func (x fastReflection_QueryClassTraceResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClassTraceResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryClassTraceResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClassTraceResponse +} + +// 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_QueryClassTraceResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryClassTraceResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryClassTraceResponse) New() protoreflect.Message { + return new(fastReflection_QueryClassTraceResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryClassTraceResponse) Interface() protoreflect.ProtoMessage { + return (*QueryClassTraceResponse)(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_QueryClassTraceResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ClassTrace != nil { + value := protoreflect.ValueOfMessage(x.ClassTrace.ProtoReflect()) + if !f(fd_QueryClassTraceResponse_class_trace, 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_QueryClassTraceResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTraceResponse.class_trace": + return x.ClassTrace != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTraceResponse")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTraceResponse 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_QueryClassTraceResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTraceResponse.class_trace": + x.ClassTrace = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTraceResponse")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTraceResponse 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_QueryClassTraceResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTraceResponse.class_trace": + value := x.ClassTrace + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTraceResponse")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTraceResponse 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_QueryClassTraceResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTraceResponse.class_trace": + x.ClassTrace = value.Message().Interface().(*ClassTrace) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTraceResponse")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTraceResponse 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_QueryClassTraceResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTraceResponse.class_trace": + if x.ClassTrace == nil { + x.ClassTrace = new(ClassTrace) + } + return protoreflect.ValueOfMessage(x.ClassTrace.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTraceResponse")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTraceResponse 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_QueryClassTraceResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTraceResponse.class_trace": + m := new(ClassTrace) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTraceResponse")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTraceResponse 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_QueryClassTraceResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.apps.mt_transfer.v1.QueryClassTraceResponse", 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_QueryClassTraceResponse) 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_QueryClassTraceResponse) 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_QueryClassTraceResponse) 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_QueryClassTraceResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryClassTraceResponse) + 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.ClassTrace != nil { + l = options.Size(x.ClassTrace) + 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().(*QueryClassTraceResponse) + 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.ClassTrace != nil { + encoded, err := options.Marshal(x.ClassTrace) + 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().(*QueryClassTraceResponse) + 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: QueryClassTraceResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryClassTraceResponse: 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 ClassTrace", 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.ClassTrace == nil { + x.ClassTrace = &ClassTrace{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ClassTrace); 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_QueryClassTracesRequest protoreflect.MessageDescriptor + fd_QueryClassTracesRequest_pagination protoreflect.FieldDescriptor +) + +func init() { + file_tibc_apps_mt_transfer_v1_query_proto_init() + md_QueryClassTracesRequest = File_tibc_apps_mt_transfer_v1_query_proto.Messages().ByName("QueryClassTracesRequest") + fd_QueryClassTracesRequest_pagination = md_QueryClassTracesRequest.Fields().ByName("pagination") +} + +var _ protoreflect.Message = (*fastReflection_QueryClassTracesRequest)(nil) + +type fastReflection_QueryClassTracesRequest QueryClassTracesRequest + +func (x *QueryClassTracesRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryClassTracesRequest)(x) +} + +func (x *QueryClassTracesRequest) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_apps_mt_transfer_v1_query_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_QueryClassTracesRequest_messageType fastReflection_QueryClassTracesRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryClassTracesRequest_messageType{} + +type fastReflection_QueryClassTracesRequest_messageType struct{} + +func (x fastReflection_QueryClassTracesRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryClassTracesRequest)(nil) +} +func (x fastReflection_QueryClassTracesRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryClassTracesRequest) +} +func (x fastReflection_QueryClassTracesRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClassTracesRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryClassTracesRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClassTracesRequest +} + +// 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_QueryClassTracesRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryClassTracesRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryClassTracesRequest) New() protoreflect.Message { + return new(fastReflection_QueryClassTracesRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryClassTracesRequest) Interface() protoreflect.ProtoMessage { + return (*QueryClassTracesRequest)(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_QueryClassTracesRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Pagination != nil { + value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + if !f(fd_QueryClassTracesRequest_pagination, 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_QueryClassTracesRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTracesRequest.pagination": + return x.Pagination != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTracesRequest")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTracesRequest 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_QueryClassTracesRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTracesRequest.pagination": + x.Pagination = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTracesRequest")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTracesRequest 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_QueryClassTracesRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTracesRequest.pagination": + value := x.Pagination + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTracesRequest")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTracesRequest 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_QueryClassTracesRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTracesRequest.pagination": + x.Pagination = value.Message().Interface().(*v1beta1.PageRequest) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTracesRequest")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTracesRequest 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_QueryClassTracesRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTracesRequest.pagination": + if x.Pagination == nil { + x.Pagination = new(v1beta1.PageRequest) + } + return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTracesRequest")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTracesRequest 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_QueryClassTracesRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTracesRequest.pagination": + m := new(v1beta1.PageRequest) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTracesRequest")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTracesRequest 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_QueryClassTracesRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.apps.mt_transfer.v1.QueryClassTracesRequest", 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_QueryClassTracesRequest) 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_QueryClassTracesRequest) 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_QueryClassTracesRequest) 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_QueryClassTracesRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryClassTracesRequest) + 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.Pagination != nil { + l = options.Size(x.Pagination) + 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().(*QueryClassTracesRequest) + 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.Pagination != nil { + encoded, err := options.Marshal(x.Pagination) + 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().(*QueryClassTracesRequest) + 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: QueryClassTracesRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryClassTracesRequest: 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 Pagination", 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.Pagination == nil { + x.Pagination = &v1beta1.PageRequest{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); 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 = (*_QueryClassTracesResponse_1_list)(nil) + +type _QueryClassTracesResponse_1_list struct { + list *[]*ClassTrace +} + +func (x *_QueryClassTracesResponse_1_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_QueryClassTracesResponse_1_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_QueryClassTracesResponse_1_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*ClassTrace) + (*x.list)[i] = concreteValue +} + +func (x *_QueryClassTracesResponse_1_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*ClassTrace) + *x.list = append(*x.list, concreteValue) +} + +func (x *_QueryClassTracesResponse_1_list) AppendMutable() protoreflect.Value { + v := new(ClassTrace) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_QueryClassTracesResponse_1_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_QueryClassTracesResponse_1_list) NewElement() protoreflect.Value { + v := new(ClassTrace) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_QueryClassTracesResponse_1_list) IsValid() bool { + return x.list != nil +} + +var ( + md_QueryClassTracesResponse protoreflect.MessageDescriptor + fd_QueryClassTracesResponse_class_traces protoreflect.FieldDescriptor + fd_QueryClassTracesResponse_pagination protoreflect.FieldDescriptor +) + +func init() { + file_tibc_apps_mt_transfer_v1_query_proto_init() + md_QueryClassTracesResponse = File_tibc_apps_mt_transfer_v1_query_proto.Messages().ByName("QueryClassTracesResponse") + fd_QueryClassTracesResponse_class_traces = md_QueryClassTracesResponse.Fields().ByName("class_traces") + fd_QueryClassTracesResponse_pagination = md_QueryClassTracesResponse.Fields().ByName("pagination") +} + +var _ protoreflect.Message = (*fastReflection_QueryClassTracesResponse)(nil) + +type fastReflection_QueryClassTracesResponse QueryClassTracesResponse + +func (x *QueryClassTracesResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryClassTracesResponse)(x) +} + +func (x *QueryClassTracesResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_apps_mt_transfer_v1_query_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryClassTracesResponse_messageType fastReflection_QueryClassTracesResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryClassTracesResponse_messageType{} + +type fastReflection_QueryClassTracesResponse_messageType struct{} + +func (x fastReflection_QueryClassTracesResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryClassTracesResponse)(nil) +} +func (x fastReflection_QueryClassTracesResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryClassTracesResponse) +} +func (x fastReflection_QueryClassTracesResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClassTracesResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryClassTracesResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClassTracesResponse +} + +// 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_QueryClassTracesResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryClassTracesResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryClassTracesResponse) New() protoreflect.Message { + return new(fastReflection_QueryClassTracesResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryClassTracesResponse) Interface() protoreflect.ProtoMessage { + return (*QueryClassTracesResponse)(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_QueryClassTracesResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.ClassTraces) != 0 { + value := protoreflect.ValueOfList(&_QueryClassTracesResponse_1_list{list: &x.ClassTraces}) + if !f(fd_QueryClassTracesResponse_class_traces, value) { + return + } + } + if x.Pagination != nil { + value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + if !f(fd_QueryClassTracesResponse_pagination, 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_QueryClassTracesResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTracesResponse.class_traces": + return len(x.ClassTraces) != 0 + case "tibc.apps.mt_transfer.v1.QueryClassTracesResponse.pagination": + return x.Pagination != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTracesResponse")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTracesResponse 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_QueryClassTracesResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTracesResponse.class_traces": + x.ClassTraces = nil + case "tibc.apps.mt_transfer.v1.QueryClassTracesResponse.pagination": + x.Pagination = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTracesResponse")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTracesResponse 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_QueryClassTracesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTracesResponse.class_traces": + if len(x.ClassTraces) == 0 { + return protoreflect.ValueOfList(&_QueryClassTracesResponse_1_list{}) + } + listValue := &_QueryClassTracesResponse_1_list{list: &x.ClassTraces} + return protoreflect.ValueOfList(listValue) + case "tibc.apps.mt_transfer.v1.QueryClassTracesResponse.pagination": + value := x.Pagination + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTracesResponse")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTracesResponse 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_QueryClassTracesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTracesResponse.class_traces": + lv := value.List() + clv := lv.(*_QueryClassTracesResponse_1_list) + x.ClassTraces = *clv.list + case "tibc.apps.mt_transfer.v1.QueryClassTracesResponse.pagination": + x.Pagination = value.Message().Interface().(*v1beta1.PageResponse) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTracesResponse")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTracesResponse 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_QueryClassTracesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTracesResponse.class_traces": + if x.ClassTraces == nil { + x.ClassTraces = []*ClassTrace{} + } + value := &_QueryClassTracesResponse_1_list{list: &x.ClassTraces} + return protoreflect.ValueOfList(value) + case "tibc.apps.mt_transfer.v1.QueryClassTracesResponse.pagination": + if x.Pagination == nil { + x.Pagination = new(v1beta1.PageResponse) + } + return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTracesResponse")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTracesResponse 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_QueryClassTracesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.QueryClassTracesResponse.class_traces": + list := []*ClassTrace{} + return protoreflect.ValueOfList(&_QueryClassTracesResponse_1_list{list: &list}) + case "tibc.apps.mt_transfer.v1.QueryClassTracesResponse.pagination": + m := new(v1beta1.PageResponse) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.QueryClassTracesResponse")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.QueryClassTracesResponse 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_QueryClassTracesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.apps.mt_transfer.v1.QueryClassTracesResponse", 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_QueryClassTracesResponse) 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_QueryClassTracesResponse) 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_QueryClassTracesResponse) 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_QueryClassTracesResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryClassTracesResponse) + 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.ClassTraces) > 0 { + for _, e := range x.ClassTraces { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.Pagination != nil { + l = options.Size(x.Pagination) + 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().(*QueryClassTracesResponse) + 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.Pagination != nil { + encoded, err := options.Marshal(x.Pagination) + 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.ClassTraces) > 0 { + for iNdEx := len(x.ClassTraces) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.ClassTraces[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().(*QueryClassTracesResponse) + 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: QueryClassTracesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryClassTracesResponse: 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 ClassTraces", 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.ClassTraces = append(x.ClassTraces, &ClassTrace{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ClassTraces[len(x.ClassTraces)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", 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.Pagination == nil { + x.Pagination = &v1beta1.PageResponse{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); 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: tibc/apps/mt_transfer/v1/query.proto + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// QueryClassTraceRequest is the request type for the Query/ClassTrace RPC +// method +type QueryClassTraceRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // hash (in hex format) of the class trace information. + Hash string `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"` +} + +func (x *QueryClassTraceRequest) Reset() { + *x = QueryClassTraceRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_apps_mt_transfer_v1_query_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryClassTraceRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryClassTraceRequest) ProtoMessage() {} + +// Deprecated: Use QueryClassTraceRequest.ProtoReflect.Descriptor instead. +func (*QueryClassTraceRequest) Descriptor() ([]byte, []int) { + return file_tibc_apps_mt_transfer_v1_query_proto_rawDescGZIP(), []int{0} +} + +func (x *QueryClassTraceRequest) GetHash() string { + if x != nil { + return x.Hash + } + return "" +} + +// QueryClassTraceResponse is the response type for the Query/ClassTrace RPC +// method. +type QueryClassTraceResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // class_trace returns the requested class trace information. + ClassTrace *ClassTrace `protobuf:"bytes,1,opt,name=class_trace,json=classTrace,proto3" json:"class_trace,omitempty"` +} + +func (x *QueryClassTraceResponse) Reset() { + *x = QueryClassTraceResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_apps_mt_transfer_v1_query_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryClassTraceResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryClassTraceResponse) ProtoMessage() {} + +// Deprecated: Use QueryClassTraceResponse.ProtoReflect.Descriptor instead. +func (*QueryClassTraceResponse) Descriptor() ([]byte, []int) { + return file_tibc_apps_mt_transfer_v1_query_proto_rawDescGZIP(), []int{1} +} + +func (x *QueryClassTraceResponse) GetClassTrace() *ClassTrace { + if x != nil { + return x.ClassTrace + } + return nil +} + +// QueryConnectionsRequest is the request type for the Query/ClassTraces RPC +// method +type QueryClassTracesRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // pagination defines an optional pagination for the request. + Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (x *QueryClassTracesRequest) Reset() { + *x = QueryClassTracesRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_apps_mt_transfer_v1_query_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryClassTracesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryClassTracesRequest) ProtoMessage() {} + +// Deprecated: Use QueryClassTracesRequest.ProtoReflect.Descriptor instead. +func (*QueryClassTracesRequest) Descriptor() ([]byte, []int) { + return file_tibc_apps_mt_transfer_v1_query_proto_rawDescGZIP(), []int{2} +} + +func (x *QueryClassTracesRequest) GetPagination() *v1beta1.PageRequest { + if x != nil { + return x.Pagination + } + return nil +} + +// QueryConnectionsResponse is the response type for the Query/ClassTraces RPC +// method. +type QueryClassTracesResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // class_traces returns all class trace information. + ClassTraces []*ClassTrace `protobuf:"bytes,1,rep,name=class_traces,json=classTraces,proto3" json:"class_traces,omitempty"` + // pagination defines the pagination in the response. + Pagination *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (x *QueryClassTracesResponse) Reset() { + *x = QueryClassTracesResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_apps_mt_transfer_v1_query_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryClassTracesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryClassTracesResponse) ProtoMessage() {} + +// Deprecated: Use QueryClassTracesResponse.ProtoReflect.Descriptor instead. +func (*QueryClassTracesResponse) Descriptor() ([]byte, []int) { + return file_tibc_apps_mt_transfer_v1_query_proto_rawDescGZIP(), []int{3} +} + +func (x *QueryClassTracesResponse) GetClassTraces() []*ClassTrace { + if x != nil { + return x.ClassTraces + } + return nil +} + +func (x *QueryClassTracesResponse) GetPagination() *v1beta1.PageResponse { + if x != nil { + return x.Pagination + } + return nil +} + +var File_tibc_apps_mt_transfer_v1_query_proto protoreflect.FileDescriptor + +var file_tibc_apps_mt_transfer_v1_query_proto_rawDesc = []byte{ + 0x0a, 0x24, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x61, 0x70, 0x70, 0x73, 0x2f, 0x6d, 0x74, 0x5f, 0x74, + 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x76, 0x31, 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x18, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, + 0x73, 0x2e, 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, + 0x61, 0x73, 0x65, 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, + 0x31, 0x2f, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x2a, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x61, 0x70, 0x70, 0x73, 0x2f, 0x6d, 0x74, + 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x74, 0x5f, + 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x2c, 0x0a, 0x16, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, 0x65, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x61, 0x73, 0x68, 0x22, 0x60, 0x0a, 0x17, 0x51, 0x75, + 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x45, 0x0a, 0x0b, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x74, + 0x72, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x74, 0x69, 0x62, + 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, 0x65, + 0x52, 0x0a, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, 0x65, 0x22, 0x61, 0x0a, 0x17, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, 0x65, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, + 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, + 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, + 0xbc, 0x01, 0x0a, 0x18, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, + 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x57, 0x0a, 0x0c, + 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x74, 0x72, 0x61, 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x6d, + 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, + 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, 0x65, 0x42, 0x0e, 0xc8, 0xde, 0x1f, 0x00, 0xaa, 0xdf, + 0x1f, 0x06, 0x54, 0x72, 0x61, 0x63, 0x65, 0x73, 0x52, 0x0b, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x54, + 0x72, 0x61, 0x63, 0x65, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, + 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, + 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0xd9, + 0x02, 0x0a, 0x05, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0xa8, 0x01, 0x0a, 0x0a, 0x43, 0x6c, 0x61, + 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, 0x65, 0x12, 0x30, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, + 0x70, 0x70, 0x73, 0x2e, 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, + 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x74, 0x69, 0x62, 0x63, + 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x54, + 0x72, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x2f, 0x12, 0x2d, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x61, 0x70, 0x70, 0x73, + 0x2f, 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x76, 0x31, 0x2f, + 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x74, 0x72, 0x61, 0x63, 0x65, 0x73, 0x2f, 0x7b, 0x68, 0x61, + 0x73, 0x68, 0x7d, 0x12, 0xa4, 0x01, 0x0a, 0x0b, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, + 0x63, 0x65, 0x73, 0x12, 0x31, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, + 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, 0x65, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x32, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, + 0x70, 0x73, 0x2e, 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, + 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2e, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x28, 0x12, 0x26, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x61, 0x70, 0x70, 0x73, 0x2f, 0x6d, + 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6c, + 0x61, 0x73, 0x73, 0x5f, 0x74, 0x72, 0x61, 0x63, 0x65, 0x73, 0x42, 0xf2, 0x01, 0x0a, 0x1c, 0x63, + 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x6d, 0x74, 0x5f, + 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x42, 0x0a, 0x51, 0x75, 0x65, + 0x72, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x47, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, 0x2f, + 0x74, 0x69, 0x62, 0x63, 0x2d, 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, + 0x2f, 0x61, 0x70, 0x70, 0x73, 0x2f, 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, + 0x72, 0x2f, 0x76, 0x31, 0x3b, 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, + 0x76, 0x31, 0xa2, 0x02, 0x03, 0x54, 0x41, 0x4d, 0xaa, 0x02, 0x17, 0x54, 0x69, 0x62, 0x63, 0x2e, + 0x41, 0x70, 0x70, 0x73, 0x2e, 0x4d, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, + 0x56, 0x31, 0xca, 0x02, 0x17, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x41, 0x70, 0x70, 0x73, 0x5c, 0x4d, + 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x23, 0x54, + 0x69, 0x62, 0x63, 0x5c, 0x41, 0x70, 0x70, 0x73, 0x5c, 0x4d, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, + 0x66, 0x65, 0x72, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x1a, 0x54, 0x69, 0x62, 0x63, 0x3a, 0x3a, 0x41, 0x70, 0x70, 0x73, 0x3a, + 0x3a, 0x4d, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x3a, 0x3a, 0x56, 0x31, 0x62, + 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_apps_mt_transfer_v1_query_proto_rawDescOnce sync.Once + file_tibc_apps_mt_transfer_v1_query_proto_rawDescData = file_tibc_apps_mt_transfer_v1_query_proto_rawDesc +) + +func file_tibc_apps_mt_transfer_v1_query_proto_rawDescGZIP() []byte { + file_tibc_apps_mt_transfer_v1_query_proto_rawDescOnce.Do(func() { + file_tibc_apps_mt_transfer_v1_query_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_apps_mt_transfer_v1_query_proto_rawDescData) + }) + return file_tibc_apps_mt_transfer_v1_query_proto_rawDescData +} + +var file_tibc_apps_mt_transfer_v1_query_proto_msgTypes = make([]protoimpl.MessageInfo, 4) +var file_tibc_apps_mt_transfer_v1_query_proto_goTypes = []interface{}{ + (*QueryClassTraceRequest)(nil), // 0: tibc.apps.mt_transfer.v1.QueryClassTraceRequest + (*QueryClassTraceResponse)(nil), // 1: tibc.apps.mt_transfer.v1.QueryClassTraceResponse + (*QueryClassTracesRequest)(nil), // 2: tibc.apps.mt_transfer.v1.QueryClassTracesRequest + (*QueryClassTracesResponse)(nil), // 3: tibc.apps.mt_transfer.v1.QueryClassTracesResponse + (*ClassTrace)(nil), // 4: tibc.apps.mt_transfer.v1.ClassTrace + (*v1beta1.PageRequest)(nil), // 5: cosmos.base.query.v1beta1.PageRequest + (*v1beta1.PageResponse)(nil), // 6: cosmos.base.query.v1beta1.PageResponse +} +var file_tibc_apps_mt_transfer_v1_query_proto_depIdxs = []int32{ + 4, // 0: tibc.apps.mt_transfer.v1.QueryClassTraceResponse.class_trace:type_name -> tibc.apps.mt_transfer.v1.ClassTrace + 5, // 1: tibc.apps.mt_transfer.v1.QueryClassTracesRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest + 4, // 2: tibc.apps.mt_transfer.v1.QueryClassTracesResponse.class_traces:type_name -> tibc.apps.mt_transfer.v1.ClassTrace + 6, // 3: tibc.apps.mt_transfer.v1.QueryClassTracesResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse + 0, // 4: tibc.apps.mt_transfer.v1.Query.ClassTrace:input_type -> tibc.apps.mt_transfer.v1.QueryClassTraceRequest + 2, // 5: tibc.apps.mt_transfer.v1.Query.ClassTraces:input_type -> tibc.apps.mt_transfer.v1.QueryClassTracesRequest + 1, // 6: tibc.apps.mt_transfer.v1.Query.ClassTrace:output_type -> tibc.apps.mt_transfer.v1.QueryClassTraceResponse + 3, // 7: tibc.apps.mt_transfer.v1.Query.ClassTraces:output_type -> tibc.apps.mt_transfer.v1.QueryClassTracesResponse + 6, // [6:8] is the sub-list for method output_type + 4, // [4:6] is the sub-list for method input_type + 4, // [4:4] is the sub-list for extension type_name + 4, // [4:4] is the sub-list for extension extendee + 0, // [0:4] is the sub-list for field type_name +} + +func init() { file_tibc_apps_mt_transfer_v1_query_proto_init() } +func file_tibc_apps_mt_transfer_v1_query_proto_init() { + if File_tibc_apps_mt_transfer_v1_query_proto != nil { + return + } + file_tibc_apps_mt_transfer_v1_mt_transfer_proto_init() + if !protoimpl.UnsafeEnabled { + file_tibc_apps_mt_transfer_v1_query_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryClassTraceRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_apps_mt_transfer_v1_query_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryClassTraceResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_apps_mt_transfer_v1_query_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryClassTracesRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_apps_mt_transfer_v1_query_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryClassTracesResponse); 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_tibc_apps_mt_transfer_v1_query_proto_rawDesc, + NumEnums: 0, + NumMessages: 4, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_tibc_apps_mt_transfer_v1_query_proto_goTypes, + DependencyIndexes: file_tibc_apps_mt_transfer_v1_query_proto_depIdxs, + MessageInfos: file_tibc_apps_mt_transfer_v1_query_proto_msgTypes, + }.Build() + File_tibc_apps_mt_transfer_v1_query_proto = out.File + file_tibc_apps_mt_transfer_v1_query_proto_rawDesc = nil + file_tibc_apps_mt_transfer_v1_query_proto_goTypes = nil + file_tibc_apps_mt_transfer_v1_query_proto_depIdxs = nil +} diff --git a/api/tibc/apps/mt_transfer/v1/query_grpc.pb.go b/api/tibc/apps/mt_transfer/v1/query_grpc.pb.go new file mode 100644 index 00000000..a3774a97 --- /dev/null +++ b/api/tibc/apps/mt_transfer/v1/query_grpc.pb.go @@ -0,0 +1,150 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: tibc/apps/mt_transfer/v1/query.proto + +package mt_transferv1 + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + Query_ClassTrace_FullMethodName = "/tibc.apps.mt_transfer.v1.Query/ClassTrace" + Query_ClassTraces_FullMethodName = "/tibc.apps.mt_transfer.v1.Query/ClassTraces" +) + +// QueryClient is the client API for Query service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type QueryClient interface { + // ClassTrace queries a class trace information. + ClassTrace(ctx context.Context, in *QueryClassTraceRequest, opts ...grpc.CallOption) (*QueryClassTraceResponse, error) + // ClassTraces queries all class traces. + ClassTraces(ctx context.Context, in *QueryClassTracesRequest, opts ...grpc.CallOption) (*QueryClassTracesResponse, error) +} + +type queryClient struct { + cc grpc.ClientConnInterface +} + +func NewQueryClient(cc grpc.ClientConnInterface) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) ClassTrace(ctx context.Context, in *QueryClassTraceRequest, opts ...grpc.CallOption) (*QueryClassTraceResponse, error) { + out := new(QueryClassTraceResponse) + err := c.cc.Invoke(ctx, Query_ClassTrace_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) ClassTraces(ctx context.Context, in *QueryClassTracesRequest, opts ...grpc.CallOption) (*QueryClassTracesResponse, error) { + out := new(QueryClassTracesResponse) + err := c.cc.Invoke(ctx, Query_ClassTraces_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +// All implementations must embed UnimplementedQueryServer +// for forward compatibility +type QueryServer interface { + // ClassTrace queries a class trace information. + ClassTrace(context.Context, *QueryClassTraceRequest) (*QueryClassTraceResponse, error) + // ClassTraces queries all class traces. + ClassTraces(context.Context, *QueryClassTracesRequest) (*QueryClassTracesResponse, error) + mustEmbedUnimplementedQueryServer() +} + +// UnimplementedQueryServer must be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct { +} + +func (UnimplementedQueryServer) ClassTrace(context.Context, *QueryClassTraceRequest) (*QueryClassTraceResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ClassTrace not implemented") +} +func (UnimplementedQueryServer) ClassTraces(context.Context, *QueryClassTracesRequest) (*QueryClassTracesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ClassTraces not implemented") +} +func (UnimplementedQueryServer) mustEmbedUnimplementedQueryServer() {} + +// UnsafeQueryServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to QueryServer will +// result in compilation errors. +type UnsafeQueryServer interface { + mustEmbedUnimplementedQueryServer() +} + +func RegisterQueryServer(s grpc.ServiceRegistrar, srv QueryServer) { + s.RegisterService(&Query_ServiceDesc, srv) +} + +func _Query_ClassTrace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryClassTraceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ClassTrace(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_ClassTrace_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ClassTrace(ctx, req.(*QueryClassTraceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_ClassTraces_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryClassTracesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ClassTraces(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_ClassTraces_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ClassTraces(ctx, req.(*QueryClassTracesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// Query_ServiceDesc is the grpc.ServiceDesc for Query service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Query_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "tibc.apps.mt_transfer.v1.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "ClassTrace", + Handler: _Query_ClassTrace_Handler, + }, + { + MethodName: "ClassTraces", + Handler: _Query_ClassTraces_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "tibc/apps/mt_transfer/v1/query.proto", +} diff --git a/api/tibc/apps/mt_transfer/v1/tx.pulsar.go b/api/tibc/apps/mt_transfer/v1/tx.pulsar.go new file mode 100644 index 00000000..d399c811 --- /dev/null +++ b/api/tibc/apps/mt_transfer/v1/tx.pulsar.go @@ -0,0 +1,1489 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package mt_transferv1 + +import ( + fmt "fmt" + 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" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_MsgMtTransfer protoreflect.MessageDescriptor + fd_MsgMtTransfer_class protoreflect.FieldDescriptor + fd_MsgMtTransfer_id protoreflect.FieldDescriptor + fd_MsgMtTransfer_sender protoreflect.FieldDescriptor + fd_MsgMtTransfer_receiver protoreflect.FieldDescriptor + fd_MsgMtTransfer_dest_chain protoreflect.FieldDescriptor + fd_MsgMtTransfer_realay_chain protoreflect.FieldDescriptor + fd_MsgMtTransfer_dest_contract protoreflect.FieldDescriptor + fd_MsgMtTransfer_amount protoreflect.FieldDescriptor +) + +func init() { + file_tibc_apps_mt_transfer_v1_tx_proto_init() + md_MsgMtTransfer = File_tibc_apps_mt_transfer_v1_tx_proto.Messages().ByName("MsgMtTransfer") + fd_MsgMtTransfer_class = md_MsgMtTransfer.Fields().ByName("class") + fd_MsgMtTransfer_id = md_MsgMtTransfer.Fields().ByName("id") + fd_MsgMtTransfer_sender = md_MsgMtTransfer.Fields().ByName("sender") + fd_MsgMtTransfer_receiver = md_MsgMtTransfer.Fields().ByName("receiver") + fd_MsgMtTransfer_dest_chain = md_MsgMtTransfer.Fields().ByName("dest_chain") + fd_MsgMtTransfer_realay_chain = md_MsgMtTransfer.Fields().ByName("realay_chain") + fd_MsgMtTransfer_dest_contract = md_MsgMtTransfer.Fields().ByName("dest_contract") + fd_MsgMtTransfer_amount = md_MsgMtTransfer.Fields().ByName("amount") +} + +var _ protoreflect.Message = (*fastReflection_MsgMtTransfer)(nil) + +type fastReflection_MsgMtTransfer MsgMtTransfer + +func (x *MsgMtTransfer) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgMtTransfer)(x) +} + +func (x *MsgMtTransfer) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_apps_mt_transfer_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_MsgMtTransfer_messageType fastReflection_MsgMtTransfer_messageType +var _ protoreflect.MessageType = fastReflection_MsgMtTransfer_messageType{} + +type fastReflection_MsgMtTransfer_messageType struct{} + +func (x fastReflection_MsgMtTransfer_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgMtTransfer)(nil) +} +func (x fastReflection_MsgMtTransfer_messageType) New() protoreflect.Message { + return new(fastReflection_MsgMtTransfer) +} +func (x fastReflection_MsgMtTransfer_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgMtTransfer +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgMtTransfer) Descriptor() protoreflect.MessageDescriptor { + return md_MsgMtTransfer +} + +// 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_MsgMtTransfer) Type() protoreflect.MessageType { + return _fastReflection_MsgMtTransfer_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgMtTransfer) New() protoreflect.Message { + return new(fastReflection_MsgMtTransfer) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgMtTransfer) Interface() protoreflect.ProtoMessage { + return (*MsgMtTransfer)(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_MsgMtTransfer) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Class != "" { + value := protoreflect.ValueOfString(x.Class) + if !f(fd_MsgMtTransfer_class, value) { + return + } + } + if x.Id != "" { + value := protoreflect.ValueOfString(x.Id) + if !f(fd_MsgMtTransfer_id, value) { + return + } + } + if x.Sender != "" { + value := protoreflect.ValueOfString(x.Sender) + if !f(fd_MsgMtTransfer_sender, value) { + return + } + } + if x.Receiver != "" { + value := protoreflect.ValueOfString(x.Receiver) + if !f(fd_MsgMtTransfer_receiver, value) { + return + } + } + if x.DestChain != "" { + value := protoreflect.ValueOfString(x.DestChain) + if !f(fd_MsgMtTransfer_dest_chain, value) { + return + } + } + if x.RealayChain != "" { + value := protoreflect.ValueOfString(x.RealayChain) + if !f(fd_MsgMtTransfer_realay_chain, value) { + return + } + } + if x.DestContract != "" { + value := protoreflect.ValueOfString(x.DestContract) + if !f(fd_MsgMtTransfer_dest_contract, value) { + return + } + } + if x.Amount != uint64(0) { + value := protoreflect.ValueOfUint64(x.Amount) + if !f(fd_MsgMtTransfer_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_MsgMtTransfer) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.class": + return x.Class != "" + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.id": + return x.Id != "" + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.sender": + return x.Sender != "" + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.receiver": + return x.Receiver != "" + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.dest_chain": + return x.DestChain != "" + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.realay_chain": + return x.RealayChain != "" + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.dest_contract": + return x.DestContract != "" + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.amount": + return x.Amount != uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.MsgMtTransfer")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.MsgMtTransfer 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_MsgMtTransfer) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.class": + x.Class = "" + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.id": + x.Id = "" + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.sender": + x.Sender = "" + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.receiver": + x.Receiver = "" + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.dest_chain": + x.DestChain = "" + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.realay_chain": + x.RealayChain = "" + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.dest_contract": + x.DestContract = "" + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.amount": + x.Amount = uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.MsgMtTransfer")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.MsgMtTransfer 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_MsgMtTransfer) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.class": + value := x.Class + return protoreflect.ValueOfString(value) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.id": + value := x.Id + return protoreflect.ValueOfString(value) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.sender": + value := x.Sender + return protoreflect.ValueOfString(value) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.receiver": + value := x.Receiver + return protoreflect.ValueOfString(value) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.dest_chain": + value := x.DestChain + return protoreflect.ValueOfString(value) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.realay_chain": + value := x.RealayChain + return protoreflect.ValueOfString(value) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.dest_contract": + value := x.DestContract + return protoreflect.ValueOfString(value) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.amount": + value := x.Amount + return protoreflect.ValueOfUint64(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.MsgMtTransfer")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.MsgMtTransfer 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_MsgMtTransfer) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.class": + x.Class = value.Interface().(string) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.id": + x.Id = value.Interface().(string) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.sender": + x.Sender = value.Interface().(string) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.receiver": + x.Receiver = value.Interface().(string) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.dest_chain": + x.DestChain = value.Interface().(string) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.realay_chain": + x.RealayChain = value.Interface().(string) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.dest_contract": + x.DestContract = value.Interface().(string) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.amount": + x.Amount = value.Uint() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.MsgMtTransfer")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.MsgMtTransfer 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_MsgMtTransfer) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.class": + panic(fmt.Errorf("field class of message tibc.apps.mt_transfer.v1.MsgMtTransfer is not mutable")) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.id": + panic(fmt.Errorf("field id of message tibc.apps.mt_transfer.v1.MsgMtTransfer is not mutable")) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.sender": + panic(fmt.Errorf("field sender of message tibc.apps.mt_transfer.v1.MsgMtTransfer is not mutable")) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.receiver": + panic(fmt.Errorf("field receiver of message tibc.apps.mt_transfer.v1.MsgMtTransfer is not mutable")) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.dest_chain": + panic(fmt.Errorf("field dest_chain of message tibc.apps.mt_transfer.v1.MsgMtTransfer is not mutable")) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.realay_chain": + panic(fmt.Errorf("field realay_chain of message tibc.apps.mt_transfer.v1.MsgMtTransfer is not mutable")) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.dest_contract": + panic(fmt.Errorf("field dest_contract of message tibc.apps.mt_transfer.v1.MsgMtTransfer is not mutable")) + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.amount": + panic(fmt.Errorf("field amount of message tibc.apps.mt_transfer.v1.MsgMtTransfer is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.MsgMtTransfer")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.MsgMtTransfer 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_MsgMtTransfer) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.class": + return protoreflect.ValueOfString("") + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.id": + return protoreflect.ValueOfString("") + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.sender": + return protoreflect.ValueOfString("") + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.receiver": + return protoreflect.ValueOfString("") + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.dest_chain": + return protoreflect.ValueOfString("") + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.realay_chain": + return protoreflect.ValueOfString("") + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.dest_contract": + return protoreflect.ValueOfString("") + case "tibc.apps.mt_transfer.v1.MsgMtTransfer.amount": + return protoreflect.ValueOfUint64(uint64(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.MsgMtTransfer")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.MsgMtTransfer 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_MsgMtTransfer) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.apps.mt_transfer.v1.MsgMtTransfer", 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_MsgMtTransfer) 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_MsgMtTransfer) 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_MsgMtTransfer) 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_MsgMtTransfer) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgMtTransfer) + 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.Class) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Id) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Sender) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Receiver) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.DestChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.RealayChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.DestContract) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Amount != 0 { + n += 1 + runtime.Sov(uint64(x.Amount)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*MsgMtTransfer) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Amount != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Amount)) + i-- + dAtA[i] = 0x40 + } + if len(x.DestContract) > 0 { + i -= len(x.DestContract) + copy(dAtA[i:], x.DestContract) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestContract))) + i-- + dAtA[i] = 0x3a + } + if len(x.RealayChain) > 0 { + i -= len(x.RealayChain) + copy(dAtA[i:], x.RealayChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RealayChain))) + i-- + dAtA[i] = 0x32 + } + if len(x.DestChain) > 0 { + i -= len(x.DestChain) + copy(dAtA[i:], x.DestChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestChain))) + i-- + dAtA[i] = 0x2a + } + if len(x.Receiver) > 0 { + i -= len(x.Receiver) + copy(dAtA[i:], x.Receiver) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Receiver))) + i-- + dAtA[i] = 0x22 + } + if len(x.Sender) > 0 { + i -= len(x.Sender) + copy(dAtA[i:], x.Sender) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Sender))) + i-- + dAtA[i] = 0x1a + } + if len(x.Id) > 0 { + i -= len(x.Id) + copy(dAtA[i:], x.Id) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id))) + i-- + dAtA[i] = 0x12 + } + if len(x.Class) > 0 { + i -= len(x.Class) + copy(dAtA[i:], x.Class) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Class))) + 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().(*MsgMtTransfer) + 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: MsgMtTransfer: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgMtTransfer: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Class", wireType) + } + var 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.Class = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Receiver", 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.Receiver = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DestChain", 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.DestChain = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RealayChain", 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.RealayChain = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DestContract", 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.DestContract = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + x.Amount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Amount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_MsgMtTransferResponse protoreflect.MessageDescriptor +) + +func init() { + file_tibc_apps_mt_transfer_v1_tx_proto_init() + md_MsgMtTransferResponse = File_tibc_apps_mt_transfer_v1_tx_proto.Messages().ByName("MsgMtTransferResponse") +} + +var _ protoreflect.Message = (*fastReflection_MsgMtTransferResponse)(nil) + +type fastReflection_MsgMtTransferResponse MsgMtTransferResponse + +func (x *MsgMtTransferResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgMtTransferResponse)(x) +} + +func (x *MsgMtTransferResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_apps_mt_transfer_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_MsgMtTransferResponse_messageType fastReflection_MsgMtTransferResponse_messageType +var _ protoreflect.MessageType = fastReflection_MsgMtTransferResponse_messageType{} + +type fastReflection_MsgMtTransferResponse_messageType struct{} + +func (x fastReflection_MsgMtTransferResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgMtTransferResponse)(nil) +} +func (x fastReflection_MsgMtTransferResponse_messageType) New() protoreflect.Message { + return new(fastReflection_MsgMtTransferResponse) +} +func (x fastReflection_MsgMtTransferResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgMtTransferResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgMtTransferResponse) Descriptor() protoreflect.MessageDescriptor { + return md_MsgMtTransferResponse +} + +// 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_MsgMtTransferResponse) Type() protoreflect.MessageType { + return _fastReflection_MsgMtTransferResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgMtTransferResponse) New() protoreflect.Message { + return new(fastReflection_MsgMtTransferResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgMtTransferResponse) Interface() protoreflect.ProtoMessage { + return (*MsgMtTransferResponse)(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_MsgMtTransferResponse) 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_MsgMtTransferResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.MsgMtTransferResponse")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.MsgMtTransferResponse 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_MsgMtTransferResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.MsgMtTransferResponse")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.MsgMtTransferResponse 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_MsgMtTransferResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.MsgMtTransferResponse")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.MsgMtTransferResponse 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_MsgMtTransferResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.MsgMtTransferResponse")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.MsgMtTransferResponse 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_MsgMtTransferResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.MsgMtTransferResponse")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.MsgMtTransferResponse 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_MsgMtTransferResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.mt_transfer.v1.MsgMtTransferResponse")) + } + panic(fmt.Errorf("message tibc.apps.mt_transfer.v1.MsgMtTransferResponse 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_MsgMtTransferResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.apps.mt_transfer.v1.MsgMtTransferResponse", 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_MsgMtTransferResponse) 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_MsgMtTransferResponse) 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_MsgMtTransferResponse) 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_MsgMtTransferResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgMtTransferResponse) + 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().(*MsgMtTransferResponse) + 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().(*MsgMtTransferResponse) + 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: MsgMtTransferResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgMtTransferResponse: 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, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: tibc/apps/mt_transfer/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) +) + +type MsgMtTransfer struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // the class to which the mt to be transferred belongs + Class string `protobuf:"bytes,1,opt,name=class,proto3" json:"class,omitempty"` + // the mt id + Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` + // the mt sender + Sender string `protobuf:"bytes,3,opt,name=sender,proto3" json:"sender,omitempty"` + // the mt receiver + Receiver string `protobuf:"bytes,4,opt,name=receiver,proto3" json:"receiver,omitempty"` + // target chain of transmission + DestChain string `protobuf:"bytes,5,opt,name=dest_chain,json=destChain,proto3" json:"dest_chain,omitempty"` + // relay chain during transmission + RealayChain string `protobuf:"bytes,6,opt,name=realay_chain,json=realayChain,proto3" json:"realay_chain,omitempty"` + // the destination contract address to receive the nft + DestContract string `protobuf:"bytes,7,opt,name=dest_contract,json=destContract,proto3" json:"dest_contract,omitempty"` + // the amount defined by MT outside the chain + Amount uint64 `protobuf:"varint,8,opt,name=amount,proto3" json:"amount,omitempty"` +} + +func (x *MsgMtTransfer) Reset() { + *x = MsgMtTransfer{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_apps_mt_transfer_v1_tx_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgMtTransfer) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgMtTransfer) ProtoMessage() {} + +// Deprecated: Use MsgMtTransfer.ProtoReflect.Descriptor instead. +func (*MsgMtTransfer) Descriptor() ([]byte, []int) { + return file_tibc_apps_mt_transfer_v1_tx_proto_rawDescGZIP(), []int{0} +} + +func (x *MsgMtTransfer) GetClass() string { + if x != nil { + return x.Class + } + return "" +} + +func (x *MsgMtTransfer) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *MsgMtTransfer) GetSender() string { + if x != nil { + return x.Sender + } + return "" +} + +func (x *MsgMtTransfer) GetReceiver() string { + if x != nil { + return x.Receiver + } + return "" +} + +func (x *MsgMtTransfer) GetDestChain() string { + if x != nil { + return x.DestChain + } + return "" +} + +func (x *MsgMtTransfer) GetRealayChain() string { + if x != nil { + return x.RealayChain + } + return "" +} + +func (x *MsgMtTransfer) GetDestContract() string { + if x != nil { + return x.DestContract + } + return "" +} + +func (x *MsgMtTransfer) GetAmount() uint64 { + if x != nil { + return x.Amount + } + return 0 +} + +// MsgMtTransferResponse defines the Msg/MtTransfer response type. +type MsgMtTransferResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *MsgMtTransferResponse) Reset() { + *x = MsgMtTransferResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_apps_mt_transfer_v1_tx_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgMtTransferResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgMtTransferResponse) ProtoMessage() {} + +// Deprecated: Use MsgMtTransferResponse.ProtoReflect.Descriptor instead. +func (*MsgMtTransferResponse) Descriptor() ([]byte, []int) { + return file_tibc_apps_mt_transfer_v1_tx_proto_rawDescGZIP(), []int{1} +} + +var File_tibc_apps_mt_transfer_v1_tx_proto protoreflect.FileDescriptor + +var file_tibc_apps_mt_transfer_v1_tx_proto_rawDesc = []byte{ + 0x0a, 0x21, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x61, 0x70, 0x70, 0x73, 0x2f, 0x6d, 0x74, 0x5f, 0x74, + 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x76, 0x31, 0x2f, 0x74, 0x78, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x18, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x6d, + 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x1a, 0x14, 0x67, + 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x22, 0xf2, 0x01, 0x0a, 0x0d, 0x4d, 0x73, 0x67, 0x4d, 0x74, 0x54, 0x72, 0x61, + 0x6e, 0x73, 0x66, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x12, 0x0e, 0x0a, 0x02, 0x69, + 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x73, + 0x65, 0x6e, 0x64, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x65, 0x6e, + 0x64, 0x65, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x12, + 0x1d, 0x0a, 0x0a, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, 0x65, 0x73, 0x74, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x21, + 0x0a, 0x0c, 0x72, 0x65, 0x61, 0x6c, 0x61, 0x79, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x72, 0x65, 0x61, 0x6c, 0x61, 0x79, 0x43, 0x68, 0x61, 0x69, + 0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, + 0x63, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x64, 0x65, 0x73, 0x74, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, + 0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x3a, 0x08, + 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0x17, 0x0a, 0x15, 0x4d, 0x73, 0x67, 0x4d, + 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x32, 0x6d, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x66, 0x0a, 0x0a, 0x4d, 0x74, 0x54, 0x72, + 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x12, 0x27, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, + 0x70, 0x73, 0x2e, 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x4d, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x1a, + 0x2f, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x6d, 0x74, 0x5f, 0x74, + 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x4d, 0x74, + 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x42, 0xef, 0x01, 0x0a, 0x1c, 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, + 0x70, 0x73, 0x2e, 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x47, 0x67, 0x69, + 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, 0x65, + 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2d, 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x74, + 0x69, 0x62, 0x63, 0x2f, 0x61, 0x70, 0x70, 0x73, 0x2f, 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, + 0x73, 0x66, 0x65, 0x72, 0x2f, 0x76, 0x31, 0x3b, 0x6d, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, + 0x66, 0x65, 0x72, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x54, 0x41, 0x4d, 0xaa, 0x02, 0x17, 0x54, 0x69, + 0x62, 0x63, 0x2e, 0x41, 0x70, 0x70, 0x73, 0x2e, 0x4d, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, + 0x65, 0x72, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x17, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x41, 0x70, 0x70, + 0x73, 0x5c, 0x4d, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5c, 0x56, 0x31, 0xe2, + 0x02, 0x23, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x41, 0x70, 0x70, 0x73, 0x5c, 0x4d, 0x74, 0x54, 0x72, + 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x1a, 0x54, 0x69, 0x62, 0x63, 0x3a, 0x3a, 0x41, 0x70, + 0x70, 0x73, 0x3a, 0x3a, 0x4d, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x3a, 0x3a, + 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_apps_mt_transfer_v1_tx_proto_rawDescOnce sync.Once + file_tibc_apps_mt_transfer_v1_tx_proto_rawDescData = file_tibc_apps_mt_transfer_v1_tx_proto_rawDesc +) + +func file_tibc_apps_mt_transfer_v1_tx_proto_rawDescGZIP() []byte { + file_tibc_apps_mt_transfer_v1_tx_proto_rawDescOnce.Do(func() { + file_tibc_apps_mt_transfer_v1_tx_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_apps_mt_transfer_v1_tx_proto_rawDescData) + }) + return file_tibc_apps_mt_transfer_v1_tx_proto_rawDescData +} + +var file_tibc_apps_mt_transfer_v1_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_tibc_apps_mt_transfer_v1_tx_proto_goTypes = []interface{}{ + (*MsgMtTransfer)(nil), // 0: tibc.apps.mt_transfer.v1.MsgMtTransfer + (*MsgMtTransferResponse)(nil), // 1: tibc.apps.mt_transfer.v1.MsgMtTransferResponse +} +var file_tibc_apps_mt_transfer_v1_tx_proto_depIdxs = []int32{ + 0, // 0: tibc.apps.mt_transfer.v1.Msg.MtTransfer:input_type -> tibc.apps.mt_transfer.v1.MsgMtTransfer + 1, // 1: tibc.apps.mt_transfer.v1.Msg.MtTransfer:output_type -> tibc.apps.mt_transfer.v1.MsgMtTransferResponse + 1, // [1:2] is the sub-list for method output_type + 0, // [0:1] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_tibc_apps_mt_transfer_v1_tx_proto_init() } +func file_tibc_apps_mt_transfer_v1_tx_proto_init() { + if File_tibc_apps_mt_transfer_v1_tx_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_tibc_apps_mt_transfer_v1_tx_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgMtTransfer); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_apps_mt_transfer_v1_tx_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgMtTransferResponse); 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_tibc_apps_mt_transfer_v1_tx_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_tibc_apps_mt_transfer_v1_tx_proto_goTypes, + DependencyIndexes: file_tibc_apps_mt_transfer_v1_tx_proto_depIdxs, + MessageInfos: file_tibc_apps_mt_transfer_v1_tx_proto_msgTypes, + }.Build() + File_tibc_apps_mt_transfer_v1_tx_proto = out.File + file_tibc_apps_mt_transfer_v1_tx_proto_rawDesc = nil + file_tibc_apps_mt_transfer_v1_tx_proto_goTypes = nil + file_tibc_apps_mt_transfer_v1_tx_proto_depIdxs = nil +} diff --git a/api/tibc/apps/mt_transfer/v1/tx_grpc.pb.go b/api/tibc/apps/mt_transfer/v1/tx_grpc.pb.go new file mode 100644 index 00000000..0290f82f --- /dev/null +++ b/api/tibc/apps/mt_transfer/v1/tx_grpc.pb.go @@ -0,0 +1,111 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: tibc/apps/mt_transfer/v1/tx.proto + +package mt_transferv1 + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + Msg_MtTransfer_FullMethodName = "/tibc.apps.mt_transfer.v1.Msg/MtTransfer" +) + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type MsgClient interface { + // MtTransfer defines a rpc handler method for MsgMtTransfer. + MtTransfer(ctx context.Context, in *MsgMtTransfer, opts ...grpc.CallOption) (*MsgMtTransferResponse, error) +} + +type msgClient struct { + cc grpc.ClientConnInterface +} + +func NewMsgClient(cc grpc.ClientConnInterface) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) MtTransfer(ctx context.Context, in *MsgMtTransfer, opts ...grpc.CallOption) (*MsgMtTransferResponse, error) { + out := new(MsgMtTransferResponse) + err := c.cc.Invoke(ctx, Msg_MtTransfer_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +// All implementations must embed UnimplementedMsgServer +// for forward compatibility +type MsgServer interface { + // MtTransfer defines a rpc handler method for MsgMtTransfer. + MtTransfer(context.Context, *MsgMtTransfer) (*MsgMtTransferResponse, error) + mustEmbedUnimplementedMsgServer() +} + +// UnimplementedMsgServer must be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (UnimplementedMsgServer) MtTransfer(context.Context, *MsgMtTransfer) (*MsgMtTransferResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method MtTransfer not implemented") +} +func (UnimplementedMsgServer) mustEmbedUnimplementedMsgServer() {} + +// UnsafeMsgServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to MsgServer will +// result in compilation errors. +type UnsafeMsgServer interface { + mustEmbedUnimplementedMsgServer() +} + +func RegisterMsgServer(s grpc.ServiceRegistrar, srv MsgServer) { + s.RegisterService(&Msg_ServiceDesc, srv) +} + +func _Msg_MtTransfer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgMtTransfer) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).MtTransfer(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Msg_MtTransfer_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).MtTransfer(ctx, req.(*MsgMtTransfer)) + } + return interceptor(ctx, in, info, handler) +} + +// Msg_ServiceDesc is the grpc.ServiceDesc for Msg service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Msg_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "tibc.apps.mt_transfer.v1.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "MtTransfer", + Handler: _Msg_MtTransfer_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "tibc/apps/mt_transfer/v1/tx.proto", +} diff --git a/api/tibc/apps/nft_transfer/module/v1/module.pulsar.go b/api/tibc/apps/nft_transfer/module/v1/module.pulsar.go new file mode 100644 index 00000000..08ce64e3 --- /dev/null +++ b/api/tibc/apps/nft_transfer/module/v1/module.pulsar.go @@ -0,0 +1,509 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package modulev1 + +import ( + _ "cosmossdk.io/api/cosmos/app/v1alpha1" + fmt "fmt" + runtime "github.com/cosmos/cosmos-proto/runtime" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoiface "google.golang.org/protobuf/runtime/protoiface" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_Module protoreflect.MessageDescriptor +) + +func init() { + file_tibc_apps_nft_transfer_module_v1_module_proto_init() + md_Module = File_tibc_apps_nft_transfer_module_v1_module_proto.Messages().ByName("Module") +} + +var _ protoreflect.Message = (*fastReflection_Module)(nil) + +type fastReflection_Module Module + +func (x *Module) ProtoReflect() protoreflect.Message { + return (*fastReflection_Module)(x) +} + +func (x *Module) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_apps_nft_transfer_module_v1_module_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_Module_messageType fastReflection_Module_messageType +var _ protoreflect.MessageType = fastReflection_Module_messageType{} + +type fastReflection_Module_messageType struct{} + +func (x fastReflection_Module_messageType) Zero() protoreflect.Message { + return (*fastReflection_Module)(nil) +} +func (x fastReflection_Module_messageType) New() protoreflect.Message { + return new(fastReflection_Module) +} +func (x fastReflection_Module_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Module +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Module) Descriptor() protoreflect.MessageDescriptor { + return md_Module +} + +// 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_Module) Type() protoreflect.MessageType { + return _fastReflection_Module_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Module) New() protoreflect.Message { + return new(fastReflection_Module) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Module) Interface() protoreflect.ProtoMessage { + return (*Module)(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_Module) 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_Module) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.module.v1.Module")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.module.v1.Module 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_Module) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.module.v1.Module")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.module.v1.Module 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_Module) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.module.v1.Module")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.module.v1.Module 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_Module) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.module.v1.Module")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.module.v1.Module 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_Module) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.module.v1.Module")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.module.v1.Module 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_Module) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.module.v1.Module")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.module.v1.Module 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_Module) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.apps.nft_transfer.module.v1.Module", 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_Module) 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_Module) 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_Module) 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_Module) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Module) + 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().(*Module) + 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().(*Module) + 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: Module: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Module: 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, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: tibc/apps/nft_transfer/module/v1/module.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) +) + +// Module is the config object of the tibc module. +type Module struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *Module) Reset() { + *x = Module{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_apps_nft_transfer_module_v1_module_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Module) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Module) ProtoMessage() {} + +// Deprecated: Use Module.ProtoReflect.Descriptor instead. +func (*Module) Descriptor() ([]byte, []int) { + return file_tibc_apps_nft_transfer_module_v1_module_proto_rawDescGZIP(), []int{0} +} + +var File_tibc_apps_nft_transfer_module_v1_module_proto protoreflect.FileDescriptor + +var file_tibc_apps_nft_transfer_module_v1_module_proto_rawDesc = []byte{ + 0x0a, 0x2d, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x61, 0x70, 0x70, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x5f, + 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2f, + 0x76, 0x31, 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, + 0x20, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x5f, 0x74, + 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x76, + 0x31, 0x1a, 0x20, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x61, 0x70, 0x70, 0x2f, 0x76, 0x31, + 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x22, 0x4d, 0x0a, 0x06, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x3a, 0x43, 0xba, + 0xc0, 0x96, 0xda, 0x01, 0x3d, 0x0a, 0x3b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, + 0x6d, 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, + 0x2d, 0x67, 0x6f, 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x73, 0x2f, 0x74, 0x69, 0x62, 0x63, + 0x2f, 0x61, 0x70, 0x70, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, + 0x65, 0x72, 0x42, 0xa0, 0x02, 0x0a, 0x24, 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, + 0x61, 0x70, 0x70, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, + 0x72, 0x2e, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x42, 0x0b, 0x4d, 0x6f, 0x64, + 0x75, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x4a, 0x67, 0x69, 0x74, 0x68, + 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, + 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2d, 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x74, 0x69, 0x62, + 0x63, 0x2f, 0x61, 0x70, 0x70, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, + 0x66, 0x65, 0x72, 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2f, 0x76, 0x31, 0x3b, 0x6d, 0x6f, + 0x64, 0x75, 0x6c, 0x65, 0x76, 0x31, 0xa2, 0x02, 0x04, 0x54, 0x41, 0x4e, 0x4d, 0xaa, 0x02, 0x1f, + 0x54, 0x69, 0x62, 0x63, 0x2e, 0x41, 0x70, 0x70, 0x73, 0x2e, 0x4e, 0x66, 0x74, 0x54, 0x72, 0x61, + 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x56, 0x31, 0xca, + 0x02, 0x1f, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x41, 0x70, 0x70, 0x73, 0x5c, 0x4e, 0x66, 0x74, 0x54, + 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5c, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x5c, 0x56, + 0x31, 0xe2, 0x02, 0x2b, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x41, 0x70, 0x70, 0x73, 0x5c, 0x4e, 0x66, + 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5c, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, + 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, + 0x02, 0x23, 0x54, 0x69, 0x62, 0x63, 0x3a, 0x3a, 0x41, 0x70, 0x70, 0x73, 0x3a, 0x3a, 0x4e, 0x66, + 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x3a, 0x3a, 0x4d, 0x6f, 0x64, 0x75, 0x6c, + 0x65, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_apps_nft_transfer_module_v1_module_proto_rawDescOnce sync.Once + file_tibc_apps_nft_transfer_module_v1_module_proto_rawDescData = file_tibc_apps_nft_transfer_module_v1_module_proto_rawDesc +) + +func file_tibc_apps_nft_transfer_module_v1_module_proto_rawDescGZIP() []byte { + file_tibc_apps_nft_transfer_module_v1_module_proto_rawDescOnce.Do(func() { + file_tibc_apps_nft_transfer_module_v1_module_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_apps_nft_transfer_module_v1_module_proto_rawDescData) + }) + return file_tibc_apps_nft_transfer_module_v1_module_proto_rawDescData +} + +var file_tibc_apps_nft_transfer_module_v1_module_proto_msgTypes = make([]protoimpl.MessageInfo, 1) +var file_tibc_apps_nft_transfer_module_v1_module_proto_goTypes = []interface{}{ + (*Module)(nil), // 0: tibc.apps.nft_transfer.module.v1.Module +} +var file_tibc_apps_nft_transfer_module_v1_module_proto_depIdxs = []int32{ + 0, // [0:0] is the sub-list for method output_type + 0, // [0:0] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_tibc_apps_nft_transfer_module_v1_module_proto_init() } +func file_tibc_apps_nft_transfer_module_v1_module_proto_init() { + if File_tibc_apps_nft_transfer_module_v1_module_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_tibc_apps_nft_transfer_module_v1_module_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Module); 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_tibc_apps_nft_transfer_module_v1_module_proto_rawDesc, + NumEnums: 0, + NumMessages: 1, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_tibc_apps_nft_transfer_module_v1_module_proto_goTypes, + DependencyIndexes: file_tibc_apps_nft_transfer_module_v1_module_proto_depIdxs, + MessageInfos: file_tibc_apps_nft_transfer_module_v1_module_proto_msgTypes, + }.Build() + File_tibc_apps_nft_transfer_module_v1_module_proto = out.File + file_tibc_apps_nft_transfer_module_v1_module_proto_rawDesc = nil + file_tibc_apps_nft_transfer_module_v1_module_proto_goTypes = nil + file_tibc_apps_nft_transfer_module_v1_module_proto_depIdxs = nil +} diff --git a/api/tibc/apps/nft_transfer/v1/nft_transfer.pulsar.go b/api/tibc/apps/nft_transfer/v1/nft_transfer.pulsar.go new file mode 100644 index 00000000..ec5356d6 --- /dev/null +++ b/api/tibc/apps/nft_transfer/v1/nft_transfer.pulsar.go @@ -0,0 +1,1565 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package nft_transferv1 + +import ( + fmt "fmt" + 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" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_NonFungibleTokenPacketData protoreflect.MessageDescriptor + fd_NonFungibleTokenPacketData_class protoreflect.FieldDescriptor + fd_NonFungibleTokenPacketData_id protoreflect.FieldDescriptor + fd_NonFungibleTokenPacketData_uri protoreflect.FieldDescriptor + fd_NonFungibleTokenPacketData_sender protoreflect.FieldDescriptor + fd_NonFungibleTokenPacketData_receiver protoreflect.FieldDescriptor + fd_NonFungibleTokenPacketData_away_from_origin protoreflect.FieldDescriptor + fd_NonFungibleTokenPacketData_dest_contract protoreflect.FieldDescriptor +) + +func init() { + file_tibc_apps_nft_transfer_v1_nft_transfer_proto_init() + md_NonFungibleTokenPacketData = File_tibc_apps_nft_transfer_v1_nft_transfer_proto.Messages().ByName("NonFungibleTokenPacketData") + fd_NonFungibleTokenPacketData_class = md_NonFungibleTokenPacketData.Fields().ByName("class") + fd_NonFungibleTokenPacketData_id = md_NonFungibleTokenPacketData.Fields().ByName("id") + fd_NonFungibleTokenPacketData_uri = md_NonFungibleTokenPacketData.Fields().ByName("uri") + fd_NonFungibleTokenPacketData_sender = md_NonFungibleTokenPacketData.Fields().ByName("sender") + fd_NonFungibleTokenPacketData_receiver = md_NonFungibleTokenPacketData.Fields().ByName("receiver") + fd_NonFungibleTokenPacketData_away_from_origin = md_NonFungibleTokenPacketData.Fields().ByName("away_from_origin") + fd_NonFungibleTokenPacketData_dest_contract = md_NonFungibleTokenPacketData.Fields().ByName("dest_contract") +} + +var _ protoreflect.Message = (*fastReflection_NonFungibleTokenPacketData)(nil) + +type fastReflection_NonFungibleTokenPacketData NonFungibleTokenPacketData + +func (x *NonFungibleTokenPacketData) ProtoReflect() protoreflect.Message { + return (*fastReflection_NonFungibleTokenPacketData)(x) +} + +func (x *NonFungibleTokenPacketData) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_apps_nft_transfer_v1_nft_transfer_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_NonFungibleTokenPacketData_messageType fastReflection_NonFungibleTokenPacketData_messageType +var _ protoreflect.MessageType = fastReflection_NonFungibleTokenPacketData_messageType{} + +type fastReflection_NonFungibleTokenPacketData_messageType struct{} + +func (x fastReflection_NonFungibleTokenPacketData_messageType) Zero() protoreflect.Message { + return (*fastReflection_NonFungibleTokenPacketData)(nil) +} +func (x fastReflection_NonFungibleTokenPacketData_messageType) New() protoreflect.Message { + return new(fastReflection_NonFungibleTokenPacketData) +} +func (x fastReflection_NonFungibleTokenPacketData_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_NonFungibleTokenPacketData +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_NonFungibleTokenPacketData) Descriptor() protoreflect.MessageDescriptor { + return md_NonFungibleTokenPacketData +} + +// 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_NonFungibleTokenPacketData) Type() protoreflect.MessageType { + return _fastReflection_NonFungibleTokenPacketData_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_NonFungibleTokenPacketData) New() protoreflect.Message { + return new(fastReflection_NonFungibleTokenPacketData) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_NonFungibleTokenPacketData) Interface() protoreflect.ProtoMessage { + return (*NonFungibleTokenPacketData)(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_NonFungibleTokenPacketData) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Class != "" { + value := protoreflect.ValueOfString(x.Class) + if !f(fd_NonFungibleTokenPacketData_class, value) { + return + } + } + if x.Id != "" { + value := protoreflect.ValueOfString(x.Id) + if !f(fd_NonFungibleTokenPacketData_id, value) { + return + } + } + if x.Uri != "" { + value := protoreflect.ValueOfString(x.Uri) + if !f(fd_NonFungibleTokenPacketData_uri, value) { + return + } + } + if x.Sender != "" { + value := protoreflect.ValueOfString(x.Sender) + if !f(fd_NonFungibleTokenPacketData_sender, value) { + return + } + } + if x.Receiver != "" { + value := protoreflect.ValueOfString(x.Receiver) + if !f(fd_NonFungibleTokenPacketData_receiver, value) { + return + } + } + if x.AwayFromOrigin != false { + value := protoreflect.ValueOfBool(x.AwayFromOrigin) + if !f(fd_NonFungibleTokenPacketData_away_from_origin, value) { + return + } + } + if x.DestContract != "" { + value := protoreflect.ValueOfString(x.DestContract) + if !f(fd_NonFungibleTokenPacketData_dest_contract, 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_NonFungibleTokenPacketData) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.class": + return x.Class != "" + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.id": + return x.Id != "" + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.uri": + return x.Uri != "" + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.sender": + return x.Sender != "" + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.receiver": + return x.Receiver != "" + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.away_from_origin": + return x.AwayFromOrigin != false + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.dest_contract": + return x.DestContract != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData 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_NonFungibleTokenPacketData) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.class": + x.Class = "" + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.id": + x.Id = "" + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.uri": + x.Uri = "" + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.sender": + x.Sender = "" + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.receiver": + x.Receiver = "" + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.away_from_origin": + x.AwayFromOrigin = false + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.dest_contract": + x.DestContract = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData 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_NonFungibleTokenPacketData) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.class": + value := x.Class + return protoreflect.ValueOfString(value) + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.id": + value := x.Id + return protoreflect.ValueOfString(value) + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.uri": + value := x.Uri + return protoreflect.ValueOfString(value) + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.sender": + value := x.Sender + return protoreflect.ValueOfString(value) + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.receiver": + value := x.Receiver + return protoreflect.ValueOfString(value) + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.away_from_origin": + value := x.AwayFromOrigin + return protoreflect.ValueOfBool(value) + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.dest_contract": + value := x.DestContract + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData 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_NonFungibleTokenPacketData) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.class": + x.Class = value.Interface().(string) + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.id": + x.Id = value.Interface().(string) + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.uri": + x.Uri = value.Interface().(string) + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.sender": + x.Sender = value.Interface().(string) + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.receiver": + x.Receiver = value.Interface().(string) + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.away_from_origin": + x.AwayFromOrigin = value.Bool() + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.dest_contract": + x.DestContract = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData 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_NonFungibleTokenPacketData) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.class": + panic(fmt.Errorf("field class of message tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData is not mutable")) + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.id": + panic(fmt.Errorf("field id of message tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData is not mutable")) + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.uri": + panic(fmt.Errorf("field uri of message tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData is not mutable")) + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.sender": + panic(fmt.Errorf("field sender of message tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData is not mutable")) + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.receiver": + panic(fmt.Errorf("field receiver of message tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData is not mutable")) + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.away_from_origin": + panic(fmt.Errorf("field away_from_origin of message tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData is not mutable")) + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.dest_contract": + panic(fmt.Errorf("field dest_contract of message tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData 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_NonFungibleTokenPacketData) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.class": + return protoreflect.ValueOfString("") + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.id": + return protoreflect.ValueOfString("") + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.uri": + return protoreflect.ValueOfString("") + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.sender": + return protoreflect.ValueOfString("") + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.receiver": + return protoreflect.ValueOfString("") + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.away_from_origin": + return protoreflect.ValueOfBool(false) + case "tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData.dest_contract": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData 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_NonFungibleTokenPacketData) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData", 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_NonFungibleTokenPacketData) 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_NonFungibleTokenPacketData) 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_NonFungibleTokenPacketData) 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_NonFungibleTokenPacketData) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*NonFungibleTokenPacketData) + 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.Class) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Id) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Uri) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Sender) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Receiver) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.AwayFromOrigin { + n += 2 + } + l = len(x.DestContract) + 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().(*NonFungibleTokenPacketData) + 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.DestContract) > 0 { + i -= len(x.DestContract) + copy(dAtA[i:], x.DestContract) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestContract))) + i-- + dAtA[i] = 0x3a + } + if x.AwayFromOrigin { + i-- + if x.AwayFromOrigin { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x30 + } + if len(x.Receiver) > 0 { + i -= len(x.Receiver) + copy(dAtA[i:], x.Receiver) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Receiver))) + i-- + dAtA[i] = 0x2a + } + if len(x.Sender) > 0 { + i -= len(x.Sender) + copy(dAtA[i:], x.Sender) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Sender))) + i-- + dAtA[i] = 0x22 + } + if len(x.Uri) > 0 { + i -= len(x.Uri) + copy(dAtA[i:], x.Uri) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Uri))) + i-- + dAtA[i] = 0x1a + } + if len(x.Id) > 0 { + i -= len(x.Id) + copy(dAtA[i:], x.Id) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id))) + i-- + dAtA[i] = 0x12 + } + if len(x.Class) > 0 { + i -= len(x.Class) + copy(dAtA[i:], x.Class) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Class))) + 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().(*NonFungibleTokenPacketData) + 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: NonFungibleTokenPacketData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: NonFungibleTokenPacketData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Class", wireType) + } + var 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.Class = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Uri", 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.Uri = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Receiver", 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.Receiver = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field AwayFromOrigin", wireType) + } + var v 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++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.AwayFromOrigin = bool(v != 0) + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DestContract", 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.DestContract = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_ClassTrace protoreflect.MessageDescriptor + fd_ClassTrace_path protoreflect.FieldDescriptor + fd_ClassTrace_base_class protoreflect.FieldDescriptor +) + +func init() { + file_tibc_apps_nft_transfer_v1_nft_transfer_proto_init() + md_ClassTrace = File_tibc_apps_nft_transfer_v1_nft_transfer_proto.Messages().ByName("ClassTrace") + fd_ClassTrace_path = md_ClassTrace.Fields().ByName("path") + fd_ClassTrace_base_class = md_ClassTrace.Fields().ByName("base_class") +} + +var _ protoreflect.Message = (*fastReflection_ClassTrace)(nil) + +type fastReflection_ClassTrace ClassTrace + +func (x *ClassTrace) ProtoReflect() protoreflect.Message { + return (*fastReflection_ClassTrace)(x) +} + +func (x *ClassTrace) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_apps_nft_transfer_v1_nft_transfer_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_ClassTrace_messageType fastReflection_ClassTrace_messageType +var _ protoreflect.MessageType = fastReflection_ClassTrace_messageType{} + +type fastReflection_ClassTrace_messageType struct{} + +func (x fastReflection_ClassTrace_messageType) Zero() protoreflect.Message { + return (*fastReflection_ClassTrace)(nil) +} +func (x fastReflection_ClassTrace_messageType) New() protoreflect.Message { + return new(fastReflection_ClassTrace) +} +func (x fastReflection_ClassTrace_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_ClassTrace +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_ClassTrace) Descriptor() protoreflect.MessageDescriptor { + return md_ClassTrace +} + +// 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_ClassTrace) Type() protoreflect.MessageType { + return _fastReflection_ClassTrace_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_ClassTrace) New() protoreflect.Message { + return new(fastReflection_ClassTrace) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_ClassTrace) Interface() protoreflect.ProtoMessage { + return (*ClassTrace)(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_ClassTrace) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Path != "" { + value := protoreflect.ValueOfString(x.Path) + if !f(fd_ClassTrace_path, value) { + return + } + } + if x.BaseClass != "" { + value := protoreflect.ValueOfString(x.BaseClass) + if !f(fd_ClassTrace_base_class, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_ClassTrace) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.ClassTrace.path": + return x.Path != "" + case "tibc.apps.nft_transfer.v1.ClassTrace.base_class": + return x.BaseClass != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.ClassTrace")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.ClassTrace 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_ClassTrace) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.ClassTrace.path": + x.Path = "" + case "tibc.apps.nft_transfer.v1.ClassTrace.base_class": + x.BaseClass = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.ClassTrace")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.ClassTrace 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_ClassTrace) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.apps.nft_transfer.v1.ClassTrace.path": + value := x.Path + return protoreflect.ValueOfString(value) + case "tibc.apps.nft_transfer.v1.ClassTrace.base_class": + value := x.BaseClass + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.ClassTrace")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.ClassTrace 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_ClassTrace) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.ClassTrace.path": + x.Path = value.Interface().(string) + case "tibc.apps.nft_transfer.v1.ClassTrace.base_class": + x.BaseClass = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.ClassTrace")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.ClassTrace 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_ClassTrace) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.ClassTrace.path": + panic(fmt.Errorf("field path of message tibc.apps.nft_transfer.v1.ClassTrace is not mutable")) + case "tibc.apps.nft_transfer.v1.ClassTrace.base_class": + panic(fmt.Errorf("field base_class of message tibc.apps.nft_transfer.v1.ClassTrace is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.ClassTrace")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.ClassTrace 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_ClassTrace) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.ClassTrace.path": + return protoreflect.ValueOfString("") + case "tibc.apps.nft_transfer.v1.ClassTrace.base_class": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.ClassTrace")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.ClassTrace 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_ClassTrace) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.apps.nft_transfer.v1.ClassTrace", 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_ClassTrace) 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_ClassTrace) 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_ClassTrace) 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_ClassTrace) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*ClassTrace) + 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.Path) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.BaseClass) + 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().(*ClassTrace) + 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.BaseClass) > 0 { + i -= len(x.BaseClass) + copy(dAtA[i:], x.BaseClass) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.BaseClass))) + i-- + dAtA[i] = 0x12 + } + if len(x.Path) > 0 { + i -= len(x.Path) + copy(dAtA[i:], x.Path) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Path))) + 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().(*ClassTrace) + 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: ClassTrace: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ClassTrace: 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 Path", 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.Path = 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 BaseClass", 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.BaseClass = 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, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: tibc/apps/nft_transfer/v1/nft_transfer.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) +) + +type NonFungibleTokenPacketData struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // the class to which the NFT to be transferred belongs + Class string `protobuf:"bytes,1,opt,name=class,proto3" json:"class,omitempty"` + // the nft id + Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` + // the address defined by NFT outside the chain + Uri string `protobuf:"bytes,3,opt,name=uri,proto3" json:"uri,omitempty"` + // the nft sender + Sender string `protobuf:"bytes,4,opt,name=sender,proto3" json:"sender,omitempty"` + // the nft receiver + Receiver string `protobuf:"bytes,5,opt,name=receiver,proto3" json:"receiver,omitempty"` + // identify whether it is far away from the source chain + AwayFromOrigin bool `protobuf:"varint,6,opt,name=away_from_origin,json=awayFromOrigin,proto3" json:"away_from_origin,omitempty"` + // the destination contract address to receive the nft + DestContract string `protobuf:"bytes,7,opt,name=dest_contract,json=destContract,proto3" json:"dest_contract,omitempty"` +} + +func (x *NonFungibleTokenPacketData) Reset() { + *x = NonFungibleTokenPacketData{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_apps_nft_transfer_v1_nft_transfer_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NonFungibleTokenPacketData) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NonFungibleTokenPacketData) ProtoMessage() {} + +// Deprecated: Use NonFungibleTokenPacketData.ProtoReflect.Descriptor instead. +func (*NonFungibleTokenPacketData) Descriptor() ([]byte, []int) { + return file_tibc_apps_nft_transfer_v1_nft_transfer_proto_rawDescGZIP(), []int{0} +} + +func (x *NonFungibleTokenPacketData) GetClass() string { + if x != nil { + return x.Class + } + return "" +} + +func (x *NonFungibleTokenPacketData) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *NonFungibleTokenPacketData) GetUri() string { + if x != nil { + return x.Uri + } + return "" +} + +func (x *NonFungibleTokenPacketData) GetSender() string { + if x != nil { + return x.Sender + } + return "" +} + +func (x *NonFungibleTokenPacketData) GetReceiver() string { + if x != nil { + return x.Receiver + } + return "" +} + +func (x *NonFungibleTokenPacketData) GetAwayFromOrigin() bool { + if x != nil { + return x.AwayFromOrigin + } + return false +} + +func (x *NonFungibleTokenPacketData) GetDestContract() string { + if x != nil { + return x.DestContract + } + return "" +} + +// ClassTrace contains the base class for TICS30 Non fungible tokens and the +// source tracing information path. +type ClassTrace struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // path defines the chain of sourceChain/destChain + // identifiers used for tracing the source of the Non fungible token. + Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` + // base class of the relayed non fungible token. + BaseClass string `protobuf:"bytes,2,opt,name=base_class,json=baseClass,proto3" json:"base_class,omitempty"` +} + +func (x *ClassTrace) Reset() { + *x = ClassTrace{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_apps_nft_transfer_v1_nft_transfer_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ClassTrace) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ClassTrace) ProtoMessage() {} + +// Deprecated: Use ClassTrace.ProtoReflect.Descriptor instead. +func (*ClassTrace) Descriptor() ([]byte, []int) { + return file_tibc_apps_nft_transfer_v1_nft_transfer_proto_rawDescGZIP(), []int{1} +} + +func (x *ClassTrace) GetPath() string { + if x != nil { + return x.Path + } + return "" +} + +func (x *ClassTrace) GetBaseClass() string { + if x != nil { + return x.BaseClass + } + return "" +} + +var File_tibc_apps_nft_transfer_v1_nft_transfer_proto protoreflect.FileDescriptor + +var file_tibc_apps_nft_transfer_v1_nft_transfer_proto_rawDesc = []byte{ + 0x0a, 0x2c, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x61, 0x70, 0x70, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x5f, + 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x76, 0x31, 0x2f, 0x6e, 0x66, 0x74, 0x5f, + 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x19, + 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x5f, 0x74, 0x72, + 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, + 0xd7, 0x01, 0x0a, 0x1a, 0x4e, 0x6f, 0x6e, 0x46, 0x75, 0x6e, 0x67, 0x69, 0x62, 0x6c, 0x65, 0x54, + 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x14, + 0x0a, 0x05, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x63, + 0x6c, 0x61, 0x73, 0x73, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x02, 0x69, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x69, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x03, 0x75, 0x72, 0x69, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x12, 0x1a, + 0x0a, 0x08, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x12, 0x28, 0x0a, 0x10, 0x61, 0x77, + 0x61, 0x79, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x61, 0x77, 0x61, 0x79, 0x46, 0x72, 0x6f, 0x6d, 0x4f, 0x72, + 0x69, 0x67, 0x69, 0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x6f, 0x6e, + 0x74, 0x72, 0x61, 0x63, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x64, 0x65, 0x73, + 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x22, 0x3f, 0x0a, 0x0a, 0x43, 0x6c, 0x61, + 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x1d, 0x0a, 0x0a, 0x62, + 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x09, 0x62, 0x61, 0x73, 0x65, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x42, 0xff, 0x01, 0x0a, 0x1d, 0x63, + 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x6e, 0x66, 0x74, + 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x42, 0x10, 0x4e, 0x66, + 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, + 0x5a, 0x49, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x62, 0x69, 0x61, + 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2d, 0x67, 0x6f, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x61, 0x70, 0x70, 0x73, 0x2f, 0x6e, 0x66, 0x74, + 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x76, 0x31, 0x3b, 0x6e, 0x66, 0x74, + 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x54, 0x41, + 0x4e, 0xaa, 0x02, 0x18, 0x54, 0x69, 0x62, 0x63, 0x2e, 0x41, 0x70, 0x70, 0x73, 0x2e, 0x4e, 0x66, + 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x18, 0x54, + 0x69, 0x62, 0x63, 0x5c, 0x41, 0x70, 0x70, 0x73, 0x5c, 0x4e, 0x66, 0x74, 0x54, 0x72, 0x61, 0x6e, + 0x73, 0x66, 0x65, 0x72, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x24, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x41, + 0x70, 0x70, 0x73, 0x5c, 0x4e, 0x66, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5c, + 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, + 0x1b, 0x54, 0x69, 0x62, 0x63, 0x3a, 0x3a, 0x41, 0x70, 0x70, 0x73, 0x3a, 0x3a, 0x4e, 0x66, 0x74, + 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_apps_nft_transfer_v1_nft_transfer_proto_rawDescOnce sync.Once + file_tibc_apps_nft_transfer_v1_nft_transfer_proto_rawDescData = file_tibc_apps_nft_transfer_v1_nft_transfer_proto_rawDesc +) + +func file_tibc_apps_nft_transfer_v1_nft_transfer_proto_rawDescGZIP() []byte { + file_tibc_apps_nft_transfer_v1_nft_transfer_proto_rawDescOnce.Do(func() { + file_tibc_apps_nft_transfer_v1_nft_transfer_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_apps_nft_transfer_v1_nft_transfer_proto_rawDescData) + }) + return file_tibc_apps_nft_transfer_v1_nft_transfer_proto_rawDescData +} + +var file_tibc_apps_nft_transfer_v1_nft_transfer_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_tibc_apps_nft_transfer_v1_nft_transfer_proto_goTypes = []interface{}{ + (*NonFungibleTokenPacketData)(nil), // 0: tibc.apps.nft_transfer.v1.NonFungibleTokenPacketData + (*ClassTrace)(nil), // 1: tibc.apps.nft_transfer.v1.ClassTrace +} +var file_tibc_apps_nft_transfer_v1_nft_transfer_proto_depIdxs = []int32{ + 0, // [0:0] is the sub-list for method output_type + 0, // [0:0] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_tibc_apps_nft_transfer_v1_nft_transfer_proto_init() } +func file_tibc_apps_nft_transfer_v1_nft_transfer_proto_init() { + if File_tibc_apps_nft_transfer_v1_nft_transfer_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_tibc_apps_nft_transfer_v1_nft_transfer_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*NonFungibleTokenPacketData); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_apps_nft_transfer_v1_nft_transfer_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ClassTrace); 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_tibc_apps_nft_transfer_v1_nft_transfer_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_tibc_apps_nft_transfer_v1_nft_transfer_proto_goTypes, + DependencyIndexes: file_tibc_apps_nft_transfer_v1_nft_transfer_proto_depIdxs, + MessageInfos: file_tibc_apps_nft_transfer_v1_nft_transfer_proto_msgTypes, + }.Build() + File_tibc_apps_nft_transfer_v1_nft_transfer_proto = out.File + file_tibc_apps_nft_transfer_v1_nft_transfer_proto_rawDesc = nil + file_tibc_apps_nft_transfer_v1_nft_transfer_proto_goTypes = nil + file_tibc_apps_nft_transfer_v1_nft_transfer_proto_depIdxs = nil +} diff --git a/api/tibc/apps/nft_transfer/v1/query.pulsar.go b/api/tibc/apps/nft_transfer/v1/query.pulsar.go new file mode 100644 index 00000000..e5e5d09f --- /dev/null +++ b/api/tibc/apps/nft_transfer/v1/query.pulsar.go @@ -0,0 +1,2251 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package nft_transferv1 + +import ( + v1beta1 "cosmossdk.io/api/cosmos/base/query/v1beta1" + fmt "fmt" + runtime "github.com/cosmos/cosmos-proto/runtime" + _ "github.com/cosmos/gogoproto/gogoproto" + _ "google.golang.org/genproto/googleapis/api/annotations" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoiface "google.golang.org/protobuf/runtime/protoiface" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_QueryClassTraceRequest protoreflect.MessageDescriptor + fd_QueryClassTraceRequest_hash protoreflect.FieldDescriptor +) + +func init() { + file_tibc_apps_nft_transfer_v1_query_proto_init() + md_QueryClassTraceRequest = File_tibc_apps_nft_transfer_v1_query_proto.Messages().ByName("QueryClassTraceRequest") + fd_QueryClassTraceRequest_hash = md_QueryClassTraceRequest.Fields().ByName("hash") +} + +var _ protoreflect.Message = (*fastReflection_QueryClassTraceRequest)(nil) + +type fastReflection_QueryClassTraceRequest QueryClassTraceRequest + +func (x *QueryClassTraceRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryClassTraceRequest)(x) +} + +func (x *QueryClassTraceRequest) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_apps_nft_transfer_v1_query_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryClassTraceRequest_messageType fastReflection_QueryClassTraceRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryClassTraceRequest_messageType{} + +type fastReflection_QueryClassTraceRequest_messageType struct{} + +func (x fastReflection_QueryClassTraceRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryClassTraceRequest)(nil) +} +func (x fastReflection_QueryClassTraceRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryClassTraceRequest) +} +func (x fastReflection_QueryClassTraceRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClassTraceRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryClassTraceRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClassTraceRequest +} + +// 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_QueryClassTraceRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryClassTraceRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryClassTraceRequest) New() protoreflect.Message { + return new(fastReflection_QueryClassTraceRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryClassTraceRequest) Interface() protoreflect.ProtoMessage { + return (*QueryClassTraceRequest)(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_QueryClassTraceRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Hash != "" { + value := protoreflect.ValueOfString(x.Hash) + if !f(fd_QueryClassTraceRequest_hash, 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_QueryClassTraceRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTraceRequest.hash": + return x.Hash != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTraceRequest")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTraceRequest 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_QueryClassTraceRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTraceRequest.hash": + x.Hash = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTraceRequest")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTraceRequest 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_QueryClassTraceRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTraceRequest.hash": + value := x.Hash + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTraceRequest")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTraceRequest 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_QueryClassTraceRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTraceRequest.hash": + x.Hash = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTraceRequest")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTraceRequest 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_QueryClassTraceRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTraceRequest.hash": + panic(fmt.Errorf("field hash of message tibc.apps.nft_transfer.v1.QueryClassTraceRequest is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTraceRequest")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTraceRequest 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_QueryClassTraceRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTraceRequest.hash": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTraceRequest")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTraceRequest 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_QueryClassTraceRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.apps.nft_transfer.v1.QueryClassTraceRequest", 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_QueryClassTraceRequest) 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_QueryClassTraceRequest) 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_QueryClassTraceRequest) 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_QueryClassTraceRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryClassTraceRequest) + 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.Hash) + 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().(*QueryClassTraceRequest) + 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.Hash) > 0 { + i -= len(x.Hash) + copy(dAtA[i:], x.Hash) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Hash))) + 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().(*QueryClassTraceRequest) + 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: QueryClassTraceRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryClassTraceRequest: 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 Hash", 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.Hash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_QueryClassTraceResponse protoreflect.MessageDescriptor + fd_QueryClassTraceResponse_class_trace protoreflect.FieldDescriptor +) + +func init() { + file_tibc_apps_nft_transfer_v1_query_proto_init() + md_QueryClassTraceResponse = File_tibc_apps_nft_transfer_v1_query_proto.Messages().ByName("QueryClassTraceResponse") + fd_QueryClassTraceResponse_class_trace = md_QueryClassTraceResponse.Fields().ByName("class_trace") +} + +var _ protoreflect.Message = (*fastReflection_QueryClassTraceResponse)(nil) + +type fastReflection_QueryClassTraceResponse QueryClassTraceResponse + +func (x *QueryClassTraceResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryClassTraceResponse)(x) +} + +func (x *QueryClassTraceResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_apps_nft_transfer_v1_query_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryClassTraceResponse_messageType fastReflection_QueryClassTraceResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryClassTraceResponse_messageType{} + +type fastReflection_QueryClassTraceResponse_messageType struct{} + +func (x fastReflection_QueryClassTraceResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryClassTraceResponse)(nil) +} +func (x fastReflection_QueryClassTraceResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryClassTraceResponse) +} +func (x fastReflection_QueryClassTraceResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClassTraceResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryClassTraceResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClassTraceResponse +} + +// 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_QueryClassTraceResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryClassTraceResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryClassTraceResponse) New() protoreflect.Message { + return new(fastReflection_QueryClassTraceResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryClassTraceResponse) Interface() protoreflect.ProtoMessage { + return (*QueryClassTraceResponse)(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_QueryClassTraceResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ClassTrace != nil { + value := protoreflect.ValueOfMessage(x.ClassTrace.ProtoReflect()) + if !f(fd_QueryClassTraceResponse_class_trace, 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_QueryClassTraceResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTraceResponse.class_trace": + return x.ClassTrace != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTraceResponse")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTraceResponse 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_QueryClassTraceResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTraceResponse.class_trace": + x.ClassTrace = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTraceResponse")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTraceResponse 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_QueryClassTraceResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTraceResponse.class_trace": + value := x.ClassTrace + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTraceResponse")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTraceResponse 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_QueryClassTraceResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTraceResponse.class_trace": + x.ClassTrace = value.Message().Interface().(*ClassTrace) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTraceResponse")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTraceResponse 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_QueryClassTraceResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTraceResponse.class_trace": + if x.ClassTrace == nil { + x.ClassTrace = new(ClassTrace) + } + return protoreflect.ValueOfMessage(x.ClassTrace.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTraceResponse")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTraceResponse 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_QueryClassTraceResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTraceResponse.class_trace": + m := new(ClassTrace) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTraceResponse")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTraceResponse 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_QueryClassTraceResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.apps.nft_transfer.v1.QueryClassTraceResponse", 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_QueryClassTraceResponse) 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_QueryClassTraceResponse) 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_QueryClassTraceResponse) 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_QueryClassTraceResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryClassTraceResponse) + 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.ClassTrace != nil { + l = options.Size(x.ClassTrace) + 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().(*QueryClassTraceResponse) + 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.ClassTrace != nil { + encoded, err := options.Marshal(x.ClassTrace) + 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().(*QueryClassTraceResponse) + 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: QueryClassTraceResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryClassTraceResponse: 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 ClassTrace", 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.ClassTrace == nil { + x.ClassTrace = &ClassTrace{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ClassTrace); 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_QueryClassTracesRequest protoreflect.MessageDescriptor + fd_QueryClassTracesRequest_pagination protoreflect.FieldDescriptor +) + +func init() { + file_tibc_apps_nft_transfer_v1_query_proto_init() + md_QueryClassTracesRequest = File_tibc_apps_nft_transfer_v1_query_proto.Messages().ByName("QueryClassTracesRequest") + fd_QueryClassTracesRequest_pagination = md_QueryClassTracesRequest.Fields().ByName("pagination") +} + +var _ protoreflect.Message = (*fastReflection_QueryClassTracesRequest)(nil) + +type fastReflection_QueryClassTracesRequest QueryClassTracesRequest + +func (x *QueryClassTracesRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryClassTracesRequest)(x) +} + +func (x *QueryClassTracesRequest) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_apps_nft_transfer_v1_query_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_QueryClassTracesRequest_messageType fastReflection_QueryClassTracesRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryClassTracesRequest_messageType{} + +type fastReflection_QueryClassTracesRequest_messageType struct{} + +func (x fastReflection_QueryClassTracesRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryClassTracesRequest)(nil) +} +func (x fastReflection_QueryClassTracesRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryClassTracesRequest) +} +func (x fastReflection_QueryClassTracesRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClassTracesRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryClassTracesRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClassTracesRequest +} + +// 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_QueryClassTracesRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryClassTracesRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryClassTracesRequest) New() protoreflect.Message { + return new(fastReflection_QueryClassTracesRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryClassTracesRequest) Interface() protoreflect.ProtoMessage { + return (*QueryClassTracesRequest)(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_QueryClassTracesRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Pagination != nil { + value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + if !f(fd_QueryClassTracesRequest_pagination, 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_QueryClassTracesRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTracesRequest.pagination": + return x.Pagination != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTracesRequest")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTracesRequest 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_QueryClassTracesRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTracesRequest.pagination": + x.Pagination = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTracesRequest")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTracesRequest 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_QueryClassTracesRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTracesRequest.pagination": + value := x.Pagination + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTracesRequest")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTracesRequest 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_QueryClassTracesRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTracesRequest.pagination": + x.Pagination = value.Message().Interface().(*v1beta1.PageRequest) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTracesRequest")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTracesRequest 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_QueryClassTracesRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTracesRequest.pagination": + if x.Pagination == nil { + x.Pagination = new(v1beta1.PageRequest) + } + return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTracesRequest")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTracesRequest 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_QueryClassTracesRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTracesRequest.pagination": + m := new(v1beta1.PageRequest) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTracesRequest")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTracesRequest 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_QueryClassTracesRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.apps.nft_transfer.v1.QueryClassTracesRequest", 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_QueryClassTracesRequest) 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_QueryClassTracesRequest) 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_QueryClassTracesRequest) 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_QueryClassTracesRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryClassTracesRequest) + 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.Pagination != nil { + l = options.Size(x.Pagination) + 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().(*QueryClassTracesRequest) + 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.Pagination != nil { + encoded, err := options.Marshal(x.Pagination) + 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().(*QueryClassTracesRequest) + 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: QueryClassTracesRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryClassTracesRequest: 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 Pagination", 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.Pagination == nil { + x.Pagination = &v1beta1.PageRequest{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); 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 = (*_QueryClassTracesResponse_1_list)(nil) + +type _QueryClassTracesResponse_1_list struct { + list *[]*ClassTrace +} + +func (x *_QueryClassTracesResponse_1_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_QueryClassTracesResponse_1_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_QueryClassTracesResponse_1_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*ClassTrace) + (*x.list)[i] = concreteValue +} + +func (x *_QueryClassTracesResponse_1_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*ClassTrace) + *x.list = append(*x.list, concreteValue) +} + +func (x *_QueryClassTracesResponse_1_list) AppendMutable() protoreflect.Value { + v := new(ClassTrace) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_QueryClassTracesResponse_1_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_QueryClassTracesResponse_1_list) NewElement() protoreflect.Value { + v := new(ClassTrace) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_QueryClassTracesResponse_1_list) IsValid() bool { + return x.list != nil +} + +var ( + md_QueryClassTracesResponse protoreflect.MessageDescriptor + fd_QueryClassTracesResponse_class_traces protoreflect.FieldDescriptor + fd_QueryClassTracesResponse_pagination protoreflect.FieldDescriptor +) + +func init() { + file_tibc_apps_nft_transfer_v1_query_proto_init() + md_QueryClassTracesResponse = File_tibc_apps_nft_transfer_v1_query_proto.Messages().ByName("QueryClassTracesResponse") + fd_QueryClassTracesResponse_class_traces = md_QueryClassTracesResponse.Fields().ByName("class_traces") + fd_QueryClassTracesResponse_pagination = md_QueryClassTracesResponse.Fields().ByName("pagination") +} + +var _ protoreflect.Message = (*fastReflection_QueryClassTracesResponse)(nil) + +type fastReflection_QueryClassTracesResponse QueryClassTracesResponse + +func (x *QueryClassTracesResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryClassTracesResponse)(x) +} + +func (x *QueryClassTracesResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_apps_nft_transfer_v1_query_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryClassTracesResponse_messageType fastReflection_QueryClassTracesResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryClassTracesResponse_messageType{} + +type fastReflection_QueryClassTracesResponse_messageType struct{} + +func (x fastReflection_QueryClassTracesResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryClassTracesResponse)(nil) +} +func (x fastReflection_QueryClassTracesResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryClassTracesResponse) +} +func (x fastReflection_QueryClassTracesResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClassTracesResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryClassTracesResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClassTracesResponse +} + +// 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_QueryClassTracesResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryClassTracesResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryClassTracesResponse) New() protoreflect.Message { + return new(fastReflection_QueryClassTracesResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryClassTracesResponse) Interface() protoreflect.ProtoMessage { + return (*QueryClassTracesResponse)(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_QueryClassTracesResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.ClassTraces) != 0 { + value := protoreflect.ValueOfList(&_QueryClassTracesResponse_1_list{list: &x.ClassTraces}) + if !f(fd_QueryClassTracesResponse_class_traces, value) { + return + } + } + if x.Pagination != nil { + value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + if !f(fd_QueryClassTracesResponse_pagination, 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_QueryClassTracesResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTracesResponse.class_traces": + return len(x.ClassTraces) != 0 + case "tibc.apps.nft_transfer.v1.QueryClassTracesResponse.pagination": + return x.Pagination != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTracesResponse")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTracesResponse 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_QueryClassTracesResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTracesResponse.class_traces": + x.ClassTraces = nil + case "tibc.apps.nft_transfer.v1.QueryClassTracesResponse.pagination": + x.Pagination = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTracesResponse")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTracesResponse 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_QueryClassTracesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTracesResponse.class_traces": + if len(x.ClassTraces) == 0 { + return protoreflect.ValueOfList(&_QueryClassTracesResponse_1_list{}) + } + listValue := &_QueryClassTracesResponse_1_list{list: &x.ClassTraces} + return protoreflect.ValueOfList(listValue) + case "tibc.apps.nft_transfer.v1.QueryClassTracesResponse.pagination": + value := x.Pagination + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTracesResponse")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTracesResponse 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_QueryClassTracesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTracesResponse.class_traces": + lv := value.List() + clv := lv.(*_QueryClassTracesResponse_1_list) + x.ClassTraces = *clv.list + case "tibc.apps.nft_transfer.v1.QueryClassTracesResponse.pagination": + x.Pagination = value.Message().Interface().(*v1beta1.PageResponse) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTracesResponse")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTracesResponse 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_QueryClassTracesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTracesResponse.class_traces": + if x.ClassTraces == nil { + x.ClassTraces = []*ClassTrace{} + } + value := &_QueryClassTracesResponse_1_list{list: &x.ClassTraces} + return protoreflect.ValueOfList(value) + case "tibc.apps.nft_transfer.v1.QueryClassTracesResponse.pagination": + if x.Pagination == nil { + x.Pagination = new(v1beta1.PageResponse) + } + return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTracesResponse")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTracesResponse 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_QueryClassTracesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.QueryClassTracesResponse.class_traces": + list := []*ClassTrace{} + return protoreflect.ValueOfList(&_QueryClassTracesResponse_1_list{list: &list}) + case "tibc.apps.nft_transfer.v1.QueryClassTracesResponse.pagination": + m := new(v1beta1.PageResponse) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.QueryClassTracesResponse")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.QueryClassTracesResponse 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_QueryClassTracesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.apps.nft_transfer.v1.QueryClassTracesResponse", 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_QueryClassTracesResponse) 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_QueryClassTracesResponse) 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_QueryClassTracesResponse) 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_QueryClassTracesResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryClassTracesResponse) + 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.ClassTraces) > 0 { + for _, e := range x.ClassTraces { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.Pagination != nil { + l = options.Size(x.Pagination) + 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().(*QueryClassTracesResponse) + 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.Pagination != nil { + encoded, err := options.Marshal(x.Pagination) + 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.ClassTraces) > 0 { + for iNdEx := len(x.ClassTraces) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.ClassTraces[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().(*QueryClassTracesResponse) + 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: QueryClassTracesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryClassTracesResponse: 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 ClassTraces", 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.ClassTraces = append(x.ClassTraces, &ClassTrace{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ClassTraces[len(x.ClassTraces)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", 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.Pagination == nil { + x.Pagination = &v1beta1.PageResponse{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); 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: tibc/apps/nft_transfer/v1/query.proto + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// QueryClassTraceRequest is the request type for the Query/ClassTrace RPC +// method +type QueryClassTraceRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // hash (in hex format) of the class trace information. + Hash string `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"` +} + +func (x *QueryClassTraceRequest) Reset() { + *x = QueryClassTraceRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_apps_nft_transfer_v1_query_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryClassTraceRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryClassTraceRequest) ProtoMessage() {} + +// Deprecated: Use QueryClassTraceRequest.ProtoReflect.Descriptor instead. +func (*QueryClassTraceRequest) Descriptor() ([]byte, []int) { + return file_tibc_apps_nft_transfer_v1_query_proto_rawDescGZIP(), []int{0} +} + +func (x *QueryClassTraceRequest) GetHash() string { + if x != nil { + return x.Hash + } + return "" +} + +// QueryClassTraceResponse is the response type for the Query/ClassTrace RPC +// method. +type QueryClassTraceResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // class_trace returns the requested class trace information. + ClassTrace *ClassTrace `protobuf:"bytes,1,opt,name=class_trace,json=classTrace,proto3" json:"class_trace,omitempty"` +} + +func (x *QueryClassTraceResponse) Reset() { + *x = QueryClassTraceResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_apps_nft_transfer_v1_query_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryClassTraceResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryClassTraceResponse) ProtoMessage() {} + +// Deprecated: Use QueryClassTraceResponse.ProtoReflect.Descriptor instead. +func (*QueryClassTraceResponse) Descriptor() ([]byte, []int) { + return file_tibc_apps_nft_transfer_v1_query_proto_rawDescGZIP(), []int{1} +} + +func (x *QueryClassTraceResponse) GetClassTrace() *ClassTrace { + if x != nil { + return x.ClassTrace + } + return nil +} + +// QueryConnectionsRequest is the request type for the Query/ClassTraces RPC +// method +type QueryClassTracesRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // pagination defines an optional pagination for the request. + Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (x *QueryClassTracesRequest) Reset() { + *x = QueryClassTracesRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_apps_nft_transfer_v1_query_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryClassTracesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryClassTracesRequest) ProtoMessage() {} + +// Deprecated: Use QueryClassTracesRequest.ProtoReflect.Descriptor instead. +func (*QueryClassTracesRequest) Descriptor() ([]byte, []int) { + return file_tibc_apps_nft_transfer_v1_query_proto_rawDescGZIP(), []int{2} +} + +func (x *QueryClassTracesRequest) GetPagination() *v1beta1.PageRequest { + if x != nil { + return x.Pagination + } + return nil +} + +// QueryConnectionsResponse is the response type for the Query/ClassTraces RPC +// method. +type QueryClassTracesResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // class_traces returns all class trace information. + ClassTraces []*ClassTrace `protobuf:"bytes,1,rep,name=class_traces,json=classTraces,proto3" json:"class_traces,omitempty"` + // pagination defines the pagination in the response. + Pagination *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (x *QueryClassTracesResponse) Reset() { + *x = QueryClassTracesResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_apps_nft_transfer_v1_query_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryClassTracesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryClassTracesResponse) ProtoMessage() {} + +// Deprecated: Use QueryClassTracesResponse.ProtoReflect.Descriptor instead. +func (*QueryClassTracesResponse) Descriptor() ([]byte, []int) { + return file_tibc_apps_nft_transfer_v1_query_proto_rawDescGZIP(), []int{3} +} + +func (x *QueryClassTracesResponse) GetClassTraces() []*ClassTrace { + if x != nil { + return x.ClassTraces + } + return nil +} + +func (x *QueryClassTracesResponse) GetPagination() *v1beta1.PageResponse { + if x != nil { + return x.Pagination + } + return nil +} + +var File_tibc_apps_nft_transfer_v1_query_proto protoreflect.FileDescriptor + +var file_tibc_apps_nft_transfer_v1_query_proto_rawDesc = []byte{ + 0x0a, 0x25, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x61, 0x70, 0x70, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x5f, + 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x76, 0x31, 0x2f, 0x71, 0x75, 0x65, 0x72, + 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x19, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, + 0x70, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, + 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, + 0x2f, 0x62, 0x61, 0x73, 0x65, 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2f, 0x76, 0x31, 0x62, 0x65, + 0x74, 0x61, 0x31, 0x2f, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2c, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x61, 0x70, 0x70, 0x73, 0x2f, + 0x6e, 0x66, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x76, 0x31, 0x2f, + 0x6e, 0x66, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, + 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x22, 0x2c, 0x0a, 0x16, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, + 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x61, + 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x61, 0x73, 0x68, 0x22, 0x61, + 0x0a, 0x17, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, + 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x46, 0x0a, 0x0b, 0x63, 0x6c, 0x61, + 0x73, 0x73, 0x5f, 0x74, 0x72, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, + 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x5f, 0x74, + 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x61, 0x73, 0x73, + 0x54, 0x72, 0x61, 0x63, 0x65, 0x52, 0x0a, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, + 0x65, 0x22, 0x61, 0x0a, 0x17, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x54, + 0x72, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, + 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, + 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, + 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xbd, 0x01, 0x0a, 0x18, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, + 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x58, 0x0a, 0x0c, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x74, 0x72, 0x61, 0x63, 0x65, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, + 0x70, 0x70, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, 0x65, 0x42, 0x0e, + 0xc8, 0xde, 0x1f, 0x00, 0xaa, 0xdf, 0x1f, 0x06, 0x54, 0x72, 0x61, 0x63, 0x65, 0x73, 0x52, 0x0b, + 0x63, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, 0x65, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, + 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, + 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x32, 0xdf, 0x02, 0x0a, 0x05, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0xab, + 0x01, 0x0a, 0x0a, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, 0x65, 0x12, 0x31, 0x2e, + 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x5f, 0x74, 0x72, + 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, + 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x32, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x6e, 0x66, 0x74, + 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, + 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x36, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x30, 0x12, 0x2e, 0x2f, 0x74, + 0x69, 0x62, 0x63, 0x2f, 0x61, 0x70, 0x70, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x5f, 0x74, 0x72, 0x61, + 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x74, + 0x72, 0x61, 0x63, 0x65, 0x73, 0x2f, 0x7b, 0x68, 0x61, 0x73, 0x68, 0x7d, 0x12, 0xa7, 0x01, 0x0a, + 0x0b, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, 0x65, 0x73, 0x12, 0x32, 0x2e, 0x74, + 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x5f, 0x74, 0x72, 0x61, + 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, + 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x33, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x6e, 0x66, 0x74, + 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, + 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x54, 0x72, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x29, 0x12, 0x27, 0x2f, + 0x74, 0x69, 0x62, 0x63, 0x2f, 0x61, 0x70, 0x70, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x5f, 0x74, 0x72, + 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, + 0x74, 0x72, 0x61, 0x63, 0x65, 0x73, 0x42, 0xf9, 0x01, 0x0a, 0x1d, 0x63, 0x6f, 0x6d, 0x2e, 0x74, + 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x5f, 0x74, 0x72, 0x61, + 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x42, 0x0a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x49, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, + 0x63, 0x2d, 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x61, 0x70, + 0x70, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, + 0x76, 0x31, 0x3b, 0x6e, 0x66, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x76, + 0x31, 0xa2, 0x02, 0x03, 0x54, 0x41, 0x4e, 0xaa, 0x02, 0x18, 0x54, 0x69, 0x62, 0x63, 0x2e, 0x41, + 0x70, 0x70, 0x73, 0x2e, 0x4e, 0x66, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, + 0x56, 0x31, 0xca, 0x02, 0x18, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x41, 0x70, 0x70, 0x73, 0x5c, 0x4e, + 0x66, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x24, + 0x54, 0x69, 0x62, 0x63, 0x5c, 0x41, 0x70, 0x70, 0x73, 0x5c, 0x4e, 0x66, 0x74, 0x54, 0x72, 0x61, + 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x1b, 0x54, 0x69, 0x62, 0x63, 0x3a, 0x3a, 0x41, 0x70, 0x70, + 0x73, 0x3a, 0x3a, 0x4e, 0x66, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x3a, 0x3a, + 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_apps_nft_transfer_v1_query_proto_rawDescOnce sync.Once + file_tibc_apps_nft_transfer_v1_query_proto_rawDescData = file_tibc_apps_nft_transfer_v1_query_proto_rawDesc +) + +func file_tibc_apps_nft_transfer_v1_query_proto_rawDescGZIP() []byte { + file_tibc_apps_nft_transfer_v1_query_proto_rawDescOnce.Do(func() { + file_tibc_apps_nft_transfer_v1_query_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_apps_nft_transfer_v1_query_proto_rawDescData) + }) + return file_tibc_apps_nft_transfer_v1_query_proto_rawDescData +} + +var file_tibc_apps_nft_transfer_v1_query_proto_msgTypes = make([]protoimpl.MessageInfo, 4) +var file_tibc_apps_nft_transfer_v1_query_proto_goTypes = []interface{}{ + (*QueryClassTraceRequest)(nil), // 0: tibc.apps.nft_transfer.v1.QueryClassTraceRequest + (*QueryClassTraceResponse)(nil), // 1: tibc.apps.nft_transfer.v1.QueryClassTraceResponse + (*QueryClassTracesRequest)(nil), // 2: tibc.apps.nft_transfer.v1.QueryClassTracesRequest + (*QueryClassTracesResponse)(nil), // 3: tibc.apps.nft_transfer.v1.QueryClassTracesResponse + (*ClassTrace)(nil), // 4: tibc.apps.nft_transfer.v1.ClassTrace + (*v1beta1.PageRequest)(nil), // 5: cosmos.base.query.v1beta1.PageRequest + (*v1beta1.PageResponse)(nil), // 6: cosmos.base.query.v1beta1.PageResponse +} +var file_tibc_apps_nft_transfer_v1_query_proto_depIdxs = []int32{ + 4, // 0: tibc.apps.nft_transfer.v1.QueryClassTraceResponse.class_trace:type_name -> tibc.apps.nft_transfer.v1.ClassTrace + 5, // 1: tibc.apps.nft_transfer.v1.QueryClassTracesRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest + 4, // 2: tibc.apps.nft_transfer.v1.QueryClassTracesResponse.class_traces:type_name -> tibc.apps.nft_transfer.v1.ClassTrace + 6, // 3: tibc.apps.nft_transfer.v1.QueryClassTracesResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse + 0, // 4: tibc.apps.nft_transfer.v1.Query.ClassTrace:input_type -> tibc.apps.nft_transfer.v1.QueryClassTraceRequest + 2, // 5: tibc.apps.nft_transfer.v1.Query.ClassTraces:input_type -> tibc.apps.nft_transfer.v1.QueryClassTracesRequest + 1, // 6: tibc.apps.nft_transfer.v1.Query.ClassTrace:output_type -> tibc.apps.nft_transfer.v1.QueryClassTraceResponse + 3, // 7: tibc.apps.nft_transfer.v1.Query.ClassTraces:output_type -> tibc.apps.nft_transfer.v1.QueryClassTracesResponse + 6, // [6:8] is the sub-list for method output_type + 4, // [4:6] is the sub-list for method input_type + 4, // [4:4] is the sub-list for extension type_name + 4, // [4:4] is the sub-list for extension extendee + 0, // [0:4] is the sub-list for field type_name +} + +func init() { file_tibc_apps_nft_transfer_v1_query_proto_init() } +func file_tibc_apps_nft_transfer_v1_query_proto_init() { + if File_tibc_apps_nft_transfer_v1_query_proto != nil { + return + } + file_tibc_apps_nft_transfer_v1_nft_transfer_proto_init() + if !protoimpl.UnsafeEnabled { + file_tibc_apps_nft_transfer_v1_query_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryClassTraceRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_apps_nft_transfer_v1_query_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryClassTraceResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_apps_nft_transfer_v1_query_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryClassTracesRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_apps_nft_transfer_v1_query_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryClassTracesResponse); 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_tibc_apps_nft_transfer_v1_query_proto_rawDesc, + NumEnums: 0, + NumMessages: 4, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_tibc_apps_nft_transfer_v1_query_proto_goTypes, + DependencyIndexes: file_tibc_apps_nft_transfer_v1_query_proto_depIdxs, + MessageInfos: file_tibc_apps_nft_transfer_v1_query_proto_msgTypes, + }.Build() + File_tibc_apps_nft_transfer_v1_query_proto = out.File + file_tibc_apps_nft_transfer_v1_query_proto_rawDesc = nil + file_tibc_apps_nft_transfer_v1_query_proto_goTypes = nil + file_tibc_apps_nft_transfer_v1_query_proto_depIdxs = nil +} diff --git a/api/tibc/apps/nft_transfer/v1/query_grpc.pb.go b/api/tibc/apps/nft_transfer/v1/query_grpc.pb.go new file mode 100644 index 00000000..f994515c --- /dev/null +++ b/api/tibc/apps/nft_transfer/v1/query_grpc.pb.go @@ -0,0 +1,150 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: tibc/apps/nft_transfer/v1/query.proto + +package nft_transferv1 + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + Query_ClassTrace_FullMethodName = "/tibc.apps.nft_transfer.v1.Query/ClassTrace" + Query_ClassTraces_FullMethodName = "/tibc.apps.nft_transfer.v1.Query/ClassTraces" +) + +// QueryClient is the client API for Query service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type QueryClient interface { + // ClassTrace queries a class trace information. + ClassTrace(ctx context.Context, in *QueryClassTraceRequest, opts ...grpc.CallOption) (*QueryClassTraceResponse, error) + // ClassTraces queries all class traces. + ClassTraces(ctx context.Context, in *QueryClassTracesRequest, opts ...grpc.CallOption) (*QueryClassTracesResponse, error) +} + +type queryClient struct { + cc grpc.ClientConnInterface +} + +func NewQueryClient(cc grpc.ClientConnInterface) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) ClassTrace(ctx context.Context, in *QueryClassTraceRequest, opts ...grpc.CallOption) (*QueryClassTraceResponse, error) { + out := new(QueryClassTraceResponse) + err := c.cc.Invoke(ctx, Query_ClassTrace_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) ClassTraces(ctx context.Context, in *QueryClassTracesRequest, opts ...grpc.CallOption) (*QueryClassTracesResponse, error) { + out := new(QueryClassTracesResponse) + err := c.cc.Invoke(ctx, Query_ClassTraces_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +// All implementations must embed UnimplementedQueryServer +// for forward compatibility +type QueryServer interface { + // ClassTrace queries a class trace information. + ClassTrace(context.Context, *QueryClassTraceRequest) (*QueryClassTraceResponse, error) + // ClassTraces queries all class traces. + ClassTraces(context.Context, *QueryClassTracesRequest) (*QueryClassTracesResponse, error) + mustEmbedUnimplementedQueryServer() +} + +// UnimplementedQueryServer must be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct { +} + +func (UnimplementedQueryServer) ClassTrace(context.Context, *QueryClassTraceRequest) (*QueryClassTraceResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ClassTrace not implemented") +} +func (UnimplementedQueryServer) ClassTraces(context.Context, *QueryClassTracesRequest) (*QueryClassTracesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ClassTraces not implemented") +} +func (UnimplementedQueryServer) mustEmbedUnimplementedQueryServer() {} + +// UnsafeQueryServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to QueryServer will +// result in compilation errors. +type UnsafeQueryServer interface { + mustEmbedUnimplementedQueryServer() +} + +func RegisterQueryServer(s grpc.ServiceRegistrar, srv QueryServer) { + s.RegisterService(&Query_ServiceDesc, srv) +} + +func _Query_ClassTrace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryClassTraceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ClassTrace(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_ClassTrace_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ClassTrace(ctx, req.(*QueryClassTraceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_ClassTraces_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryClassTracesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ClassTraces(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_ClassTraces_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ClassTraces(ctx, req.(*QueryClassTracesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// Query_ServiceDesc is the grpc.ServiceDesc for Query service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Query_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "tibc.apps.nft_transfer.v1.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "ClassTrace", + Handler: _Query_ClassTrace_Handler, + }, + { + MethodName: "ClassTraces", + Handler: _Query_ClassTraces_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "tibc/apps/nft_transfer/v1/query.proto", +} diff --git a/api/tibc/apps/nft_transfer/v1/tx.pulsar.go b/api/tibc/apps/nft_transfer/v1/tx.pulsar.go new file mode 100644 index 00000000..d68b7129 --- /dev/null +++ b/api/tibc/apps/nft_transfer/v1/tx.pulsar.go @@ -0,0 +1,1432 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package nft_transferv1 + +import ( + fmt "fmt" + 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" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_MsgNftTransfer protoreflect.MessageDescriptor + fd_MsgNftTransfer_class protoreflect.FieldDescriptor + fd_MsgNftTransfer_id protoreflect.FieldDescriptor + fd_MsgNftTransfer_sender protoreflect.FieldDescriptor + fd_MsgNftTransfer_receiver protoreflect.FieldDescriptor + fd_MsgNftTransfer_dest_chain protoreflect.FieldDescriptor + fd_MsgNftTransfer_realay_chain protoreflect.FieldDescriptor + fd_MsgNftTransfer_dest_contract protoreflect.FieldDescriptor +) + +func init() { + file_tibc_apps_nft_transfer_v1_tx_proto_init() + md_MsgNftTransfer = File_tibc_apps_nft_transfer_v1_tx_proto.Messages().ByName("MsgNftTransfer") + fd_MsgNftTransfer_class = md_MsgNftTransfer.Fields().ByName("class") + fd_MsgNftTransfer_id = md_MsgNftTransfer.Fields().ByName("id") + fd_MsgNftTransfer_sender = md_MsgNftTransfer.Fields().ByName("sender") + fd_MsgNftTransfer_receiver = md_MsgNftTransfer.Fields().ByName("receiver") + fd_MsgNftTransfer_dest_chain = md_MsgNftTransfer.Fields().ByName("dest_chain") + fd_MsgNftTransfer_realay_chain = md_MsgNftTransfer.Fields().ByName("realay_chain") + fd_MsgNftTransfer_dest_contract = md_MsgNftTransfer.Fields().ByName("dest_contract") +} + +var _ protoreflect.Message = (*fastReflection_MsgNftTransfer)(nil) + +type fastReflection_MsgNftTransfer MsgNftTransfer + +func (x *MsgNftTransfer) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgNftTransfer)(x) +} + +func (x *MsgNftTransfer) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_apps_nft_transfer_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_MsgNftTransfer_messageType fastReflection_MsgNftTransfer_messageType +var _ protoreflect.MessageType = fastReflection_MsgNftTransfer_messageType{} + +type fastReflection_MsgNftTransfer_messageType struct{} + +func (x fastReflection_MsgNftTransfer_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgNftTransfer)(nil) +} +func (x fastReflection_MsgNftTransfer_messageType) New() protoreflect.Message { + return new(fastReflection_MsgNftTransfer) +} +func (x fastReflection_MsgNftTransfer_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgNftTransfer +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgNftTransfer) Descriptor() protoreflect.MessageDescriptor { + return md_MsgNftTransfer +} + +// 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_MsgNftTransfer) Type() protoreflect.MessageType { + return _fastReflection_MsgNftTransfer_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgNftTransfer) New() protoreflect.Message { + return new(fastReflection_MsgNftTransfer) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgNftTransfer) Interface() protoreflect.ProtoMessage { + return (*MsgNftTransfer)(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_MsgNftTransfer) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Class != "" { + value := protoreflect.ValueOfString(x.Class) + if !f(fd_MsgNftTransfer_class, value) { + return + } + } + if x.Id != "" { + value := protoreflect.ValueOfString(x.Id) + if !f(fd_MsgNftTransfer_id, value) { + return + } + } + if x.Sender != "" { + value := protoreflect.ValueOfString(x.Sender) + if !f(fd_MsgNftTransfer_sender, value) { + return + } + } + if x.Receiver != "" { + value := protoreflect.ValueOfString(x.Receiver) + if !f(fd_MsgNftTransfer_receiver, value) { + return + } + } + if x.DestChain != "" { + value := protoreflect.ValueOfString(x.DestChain) + if !f(fd_MsgNftTransfer_dest_chain, value) { + return + } + } + if x.RealayChain != "" { + value := protoreflect.ValueOfString(x.RealayChain) + if !f(fd_MsgNftTransfer_realay_chain, value) { + return + } + } + if x.DestContract != "" { + value := protoreflect.ValueOfString(x.DestContract) + if !f(fd_MsgNftTransfer_dest_contract, 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_MsgNftTransfer) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.class": + return x.Class != "" + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.id": + return x.Id != "" + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.sender": + return x.Sender != "" + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.receiver": + return x.Receiver != "" + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.dest_chain": + return x.DestChain != "" + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.realay_chain": + return x.RealayChain != "" + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.dest_contract": + return x.DestContract != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.MsgNftTransfer")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.MsgNftTransfer 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_MsgNftTransfer) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.class": + x.Class = "" + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.id": + x.Id = "" + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.sender": + x.Sender = "" + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.receiver": + x.Receiver = "" + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.dest_chain": + x.DestChain = "" + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.realay_chain": + x.RealayChain = "" + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.dest_contract": + x.DestContract = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.MsgNftTransfer")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.MsgNftTransfer 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_MsgNftTransfer) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.class": + value := x.Class + return protoreflect.ValueOfString(value) + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.id": + value := x.Id + return protoreflect.ValueOfString(value) + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.sender": + value := x.Sender + return protoreflect.ValueOfString(value) + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.receiver": + value := x.Receiver + return protoreflect.ValueOfString(value) + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.dest_chain": + value := x.DestChain + return protoreflect.ValueOfString(value) + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.realay_chain": + value := x.RealayChain + return protoreflect.ValueOfString(value) + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.dest_contract": + value := x.DestContract + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.MsgNftTransfer")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.MsgNftTransfer 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_MsgNftTransfer) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.class": + x.Class = value.Interface().(string) + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.id": + x.Id = value.Interface().(string) + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.sender": + x.Sender = value.Interface().(string) + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.receiver": + x.Receiver = value.Interface().(string) + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.dest_chain": + x.DestChain = value.Interface().(string) + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.realay_chain": + x.RealayChain = value.Interface().(string) + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.dest_contract": + x.DestContract = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.MsgNftTransfer")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.MsgNftTransfer 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_MsgNftTransfer) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.class": + panic(fmt.Errorf("field class of message tibc.apps.nft_transfer.v1.MsgNftTransfer is not mutable")) + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.id": + panic(fmt.Errorf("field id of message tibc.apps.nft_transfer.v1.MsgNftTransfer is not mutable")) + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.sender": + panic(fmt.Errorf("field sender of message tibc.apps.nft_transfer.v1.MsgNftTransfer is not mutable")) + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.receiver": + panic(fmt.Errorf("field receiver of message tibc.apps.nft_transfer.v1.MsgNftTransfer is not mutable")) + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.dest_chain": + panic(fmt.Errorf("field dest_chain of message tibc.apps.nft_transfer.v1.MsgNftTransfer is not mutable")) + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.realay_chain": + panic(fmt.Errorf("field realay_chain of message tibc.apps.nft_transfer.v1.MsgNftTransfer is not mutable")) + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.dest_contract": + panic(fmt.Errorf("field dest_contract of message tibc.apps.nft_transfer.v1.MsgNftTransfer is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.MsgNftTransfer")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.MsgNftTransfer 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_MsgNftTransfer) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.class": + return protoreflect.ValueOfString("") + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.id": + return protoreflect.ValueOfString("") + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.sender": + return protoreflect.ValueOfString("") + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.receiver": + return protoreflect.ValueOfString("") + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.dest_chain": + return protoreflect.ValueOfString("") + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.realay_chain": + return protoreflect.ValueOfString("") + case "tibc.apps.nft_transfer.v1.MsgNftTransfer.dest_contract": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.MsgNftTransfer")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.MsgNftTransfer 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_MsgNftTransfer) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.apps.nft_transfer.v1.MsgNftTransfer", 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_MsgNftTransfer) 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_MsgNftTransfer) 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_MsgNftTransfer) 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_MsgNftTransfer) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgNftTransfer) + 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.Class) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Id) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Sender) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Receiver) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.DestChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.RealayChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.DestContract) + 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().(*MsgNftTransfer) + 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.DestContract) > 0 { + i -= len(x.DestContract) + copy(dAtA[i:], x.DestContract) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestContract))) + i-- + dAtA[i] = 0x3a + } + if len(x.RealayChain) > 0 { + i -= len(x.RealayChain) + copy(dAtA[i:], x.RealayChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RealayChain))) + i-- + dAtA[i] = 0x32 + } + if len(x.DestChain) > 0 { + i -= len(x.DestChain) + copy(dAtA[i:], x.DestChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestChain))) + i-- + dAtA[i] = 0x2a + } + if len(x.Receiver) > 0 { + i -= len(x.Receiver) + copy(dAtA[i:], x.Receiver) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Receiver))) + i-- + dAtA[i] = 0x22 + } + if len(x.Sender) > 0 { + i -= len(x.Sender) + copy(dAtA[i:], x.Sender) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Sender))) + i-- + dAtA[i] = 0x1a + } + if len(x.Id) > 0 { + i -= len(x.Id) + copy(dAtA[i:], x.Id) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id))) + i-- + dAtA[i] = 0x12 + } + if len(x.Class) > 0 { + i -= len(x.Class) + copy(dAtA[i:], x.Class) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Class))) + 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().(*MsgNftTransfer) + 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: MsgNftTransfer: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgNftTransfer: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Class", wireType) + } + var 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.Class = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Receiver", 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.Receiver = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DestChain", 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.DestChain = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RealayChain", 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.RealayChain = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DestContract", 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.DestContract = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_MsgNftTransferResponse protoreflect.MessageDescriptor +) + +func init() { + file_tibc_apps_nft_transfer_v1_tx_proto_init() + md_MsgNftTransferResponse = File_tibc_apps_nft_transfer_v1_tx_proto.Messages().ByName("MsgNftTransferResponse") +} + +var _ protoreflect.Message = (*fastReflection_MsgNftTransferResponse)(nil) + +type fastReflection_MsgNftTransferResponse MsgNftTransferResponse + +func (x *MsgNftTransferResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgNftTransferResponse)(x) +} + +func (x *MsgNftTransferResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_apps_nft_transfer_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_MsgNftTransferResponse_messageType fastReflection_MsgNftTransferResponse_messageType +var _ protoreflect.MessageType = fastReflection_MsgNftTransferResponse_messageType{} + +type fastReflection_MsgNftTransferResponse_messageType struct{} + +func (x fastReflection_MsgNftTransferResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgNftTransferResponse)(nil) +} +func (x fastReflection_MsgNftTransferResponse_messageType) New() protoreflect.Message { + return new(fastReflection_MsgNftTransferResponse) +} +func (x fastReflection_MsgNftTransferResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgNftTransferResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgNftTransferResponse) Descriptor() protoreflect.MessageDescriptor { + return md_MsgNftTransferResponse +} + +// 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_MsgNftTransferResponse) Type() protoreflect.MessageType { + return _fastReflection_MsgNftTransferResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgNftTransferResponse) New() protoreflect.Message { + return new(fastReflection_MsgNftTransferResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgNftTransferResponse) Interface() protoreflect.ProtoMessage { + return (*MsgNftTransferResponse)(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_MsgNftTransferResponse) 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_MsgNftTransferResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.MsgNftTransferResponse")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.MsgNftTransferResponse 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_MsgNftTransferResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.MsgNftTransferResponse")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.MsgNftTransferResponse 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_MsgNftTransferResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.MsgNftTransferResponse")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.MsgNftTransferResponse 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_MsgNftTransferResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.MsgNftTransferResponse")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.MsgNftTransferResponse 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_MsgNftTransferResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.MsgNftTransferResponse")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.MsgNftTransferResponse 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_MsgNftTransferResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.apps.nft_transfer.v1.MsgNftTransferResponse")) + } + panic(fmt.Errorf("message tibc.apps.nft_transfer.v1.MsgNftTransferResponse 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_MsgNftTransferResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.apps.nft_transfer.v1.MsgNftTransferResponse", 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_MsgNftTransferResponse) 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_MsgNftTransferResponse) 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_MsgNftTransferResponse) 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_MsgNftTransferResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgNftTransferResponse) + 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().(*MsgNftTransferResponse) + 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().(*MsgNftTransferResponse) + 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: MsgNftTransferResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgNftTransferResponse: 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, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: tibc/apps/nft_transfer/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) +) + +type MsgNftTransfer struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // the class to which the NFT to be transferred belongs + Class string `protobuf:"bytes,1,opt,name=class,proto3" json:"class,omitempty"` + // the nft id + Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` + // the nft sender + Sender string `protobuf:"bytes,3,opt,name=sender,proto3" json:"sender,omitempty"` + // the nft receiver + Receiver string `protobuf:"bytes,4,opt,name=receiver,proto3" json:"receiver,omitempty"` + // target chain of transmission + DestChain string `protobuf:"bytes,5,opt,name=dest_chain,json=destChain,proto3" json:"dest_chain,omitempty"` + // relay chain during transmission + RealayChain string `protobuf:"bytes,6,opt,name=realay_chain,json=realayChain,proto3" json:"realay_chain,omitempty"` + // the destination contract address to receive the nft + DestContract string `protobuf:"bytes,7,opt,name=dest_contract,json=destContract,proto3" json:"dest_contract,omitempty"` +} + +func (x *MsgNftTransfer) Reset() { + *x = MsgNftTransfer{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_apps_nft_transfer_v1_tx_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgNftTransfer) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgNftTransfer) ProtoMessage() {} + +// Deprecated: Use MsgNftTransfer.ProtoReflect.Descriptor instead. +func (*MsgNftTransfer) Descriptor() ([]byte, []int) { + return file_tibc_apps_nft_transfer_v1_tx_proto_rawDescGZIP(), []int{0} +} + +func (x *MsgNftTransfer) GetClass() string { + if x != nil { + return x.Class + } + return "" +} + +func (x *MsgNftTransfer) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *MsgNftTransfer) GetSender() string { + if x != nil { + return x.Sender + } + return "" +} + +func (x *MsgNftTransfer) GetReceiver() string { + if x != nil { + return x.Receiver + } + return "" +} + +func (x *MsgNftTransfer) GetDestChain() string { + if x != nil { + return x.DestChain + } + return "" +} + +func (x *MsgNftTransfer) GetRealayChain() string { + if x != nil { + return x.RealayChain + } + return "" +} + +func (x *MsgNftTransfer) GetDestContract() string { + if x != nil { + return x.DestContract + } + return "" +} + +// MsgTransferResponse defines the Msg/NftTransfer response type. +type MsgNftTransferResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *MsgNftTransferResponse) Reset() { + *x = MsgNftTransferResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_apps_nft_transfer_v1_tx_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgNftTransferResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgNftTransferResponse) ProtoMessage() {} + +// Deprecated: Use MsgNftTransferResponse.ProtoReflect.Descriptor instead. +func (*MsgNftTransferResponse) Descriptor() ([]byte, []int) { + return file_tibc_apps_nft_transfer_v1_tx_proto_rawDescGZIP(), []int{1} +} + +var File_tibc_apps_nft_transfer_v1_tx_proto protoreflect.FileDescriptor + +var file_tibc_apps_nft_transfer_v1_tx_proto_rawDesc = []byte{ + 0x0a, 0x22, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x61, 0x70, 0x70, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x5f, + 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x76, 0x31, 0x2f, 0x74, 0x78, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x19, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, + 0x6e, 0x66, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x1a, + 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xdb, 0x01, 0x0a, 0x0e, 0x4d, 0x73, 0x67, 0x4e, 0x66, 0x74, + 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6c, 0x61, 0x73, + 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x12, 0x0e, + 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x16, + 0x0a, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, + 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, + 0x65, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, 0x65, 0x73, 0x74, 0x43, 0x68, 0x61, 0x69, + 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x65, 0x61, 0x6c, 0x61, 0x79, 0x5f, 0x63, 0x68, 0x61, 0x69, + 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x72, 0x65, 0x61, 0x6c, 0x61, 0x79, 0x43, + 0x68, 0x61, 0x69, 0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x6f, 0x6e, + 0x74, 0x72, 0x61, 0x63, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x64, 0x65, 0x73, + 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x3a, 0x08, 0x88, 0xa0, 0x1f, 0x00, 0xe8, + 0xa0, 0x1f, 0x00, 0x22, 0x18, 0x0a, 0x16, 0x4d, 0x73, 0x67, 0x4e, 0x66, 0x74, 0x54, 0x72, 0x61, + 0x6e, 0x73, 0x66, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0x72, 0x0a, + 0x03, 0x4d, 0x73, 0x67, 0x12, 0x6b, 0x0a, 0x0b, 0x4e, 0x66, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, + 0x66, 0x65, 0x72, 0x12, 0x29, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, + 0x6e, 0x66, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x4d, 0x73, 0x67, 0x4e, 0x66, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x1a, 0x31, + 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, 0x70, 0x70, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x5f, 0x74, + 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x4e, 0x66, + 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x42, 0xf6, 0x01, 0x0a, 0x1d, 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x61, + 0x70, 0x70, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x49, + 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, + 0x69, 0x65, 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2d, 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, + 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x61, 0x70, 0x70, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x5f, 0x74, + 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2f, 0x76, 0x31, 0x3b, 0x6e, 0x66, 0x74, 0x5f, 0x74, + 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x54, 0x41, 0x4e, 0xaa, + 0x02, 0x18, 0x54, 0x69, 0x62, 0x63, 0x2e, 0x41, 0x70, 0x70, 0x73, 0x2e, 0x4e, 0x66, 0x74, 0x54, + 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x18, 0x54, 0x69, 0x62, + 0x63, 0x5c, 0x41, 0x70, 0x70, 0x73, 0x5c, 0x4e, 0x66, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, + 0x65, 0x72, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x24, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x41, 0x70, 0x70, + 0x73, 0x5c, 0x4e, 0x66, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5c, 0x56, 0x31, + 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x1b, 0x54, + 0x69, 0x62, 0x63, 0x3a, 0x3a, 0x41, 0x70, 0x70, 0x73, 0x3a, 0x3a, 0x4e, 0x66, 0x74, 0x54, 0x72, + 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x33, +} + +var ( + file_tibc_apps_nft_transfer_v1_tx_proto_rawDescOnce sync.Once + file_tibc_apps_nft_transfer_v1_tx_proto_rawDescData = file_tibc_apps_nft_transfer_v1_tx_proto_rawDesc +) + +func file_tibc_apps_nft_transfer_v1_tx_proto_rawDescGZIP() []byte { + file_tibc_apps_nft_transfer_v1_tx_proto_rawDescOnce.Do(func() { + file_tibc_apps_nft_transfer_v1_tx_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_apps_nft_transfer_v1_tx_proto_rawDescData) + }) + return file_tibc_apps_nft_transfer_v1_tx_proto_rawDescData +} + +var file_tibc_apps_nft_transfer_v1_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_tibc_apps_nft_transfer_v1_tx_proto_goTypes = []interface{}{ + (*MsgNftTransfer)(nil), // 0: tibc.apps.nft_transfer.v1.MsgNftTransfer + (*MsgNftTransferResponse)(nil), // 1: tibc.apps.nft_transfer.v1.MsgNftTransferResponse +} +var file_tibc_apps_nft_transfer_v1_tx_proto_depIdxs = []int32{ + 0, // 0: tibc.apps.nft_transfer.v1.Msg.NftTransfer:input_type -> tibc.apps.nft_transfer.v1.MsgNftTransfer + 1, // 1: tibc.apps.nft_transfer.v1.Msg.NftTransfer:output_type -> tibc.apps.nft_transfer.v1.MsgNftTransferResponse + 1, // [1:2] is the sub-list for method output_type + 0, // [0:1] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_tibc_apps_nft_transfer_v1_tx_proto_init() } +func file_tibc_apps_nft_transfer_v1_tx_proto_init() { + if File_tibc_apps_nft_transfer_v1_tx_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_tibc_apps_nft_transfer_v1_tx_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgNftTransfer); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_apps_nft_transfer_v1_tx_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgNftTransferResponse); 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_tibc_apps_nft_transfer_v1_tx_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_tibc_apps_nft_transfer_v1_tx_proto_goTypes, + DependencyIndexes: file_tibc_apps_nft_transfer_v1_tx_proto_depIdxs, + MessageInfos: file_tibc_apps_nft_transfer_v1_tx_proto_msgTypes, + }.Build() + File_tibc_apps_nft_transfer_v1_tx_proto = out.File + file_tibc_apps_nft_transfer_v1_tx_proto_rawDesc = nil + file_tibc_apps_nft_transfer_v1_tx_proto_goTypes = nil + file_tibc_apps_nft_transfer_v1_tx_proto_depIdxs = nil +} diff --git a/api/tibc/apps/nft_transfer/v1/tx_grpc.pb.go b/api/tibc/apps/nft_transfer/v1/tx_grpc.pb.go new file mode 100644 index 00000000..45c0e3d3 --- /dev/null +++ b/api/tibc/apps/nft_transfer/v1/tx_grpc.pb.go @@ -0,0 +1,111 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: tibc/apps/nft_transfer/v1/tx.proto + +package nft_transferv1 + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + Msg_NftTransfer_FullMethodName = "/tibc.apps.nft_transfer.v1.Msg/NftTransfer" +) + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type MsgClient interface { + // NftTransfer defines a rpc handler method for MsgNftTransfer. + NftTransfer(ctx context.Context, in *MsgNftTransfer, opts ...grpc.CallOption) (*MsgNftTransferResponse, error) +} + +type msgClient struct { + cc grpc.ClientConnInterface +} + +func NewMsgClient(cc grpc.ClientConnInterface) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) NftTransfer(ctx context.Context, in *MsgNftTransfer, opts ...grpc.CallOption) (*MsgNftTransferResponse, error) { + out := new(MsgNftTransferResponse) + err := c.cc.Invoke(ctx, Msg_NftTransfer_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +// All implementations must embed UnimplementedMsgServer +// for forward compatibility +type MsgServer interface { + // NftTransfer defines a rpc handler method for MsgNftTransfer. + NftTransfer(context.Context, *MsgNftTransfer) (*MsgNftTransferResponse, error) + mustEmbedUnimplementedMsgServer() +} + +// UnimplementedMsgServer must be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (UnimplementedMsgServer) NftTransfer(context.Context, *MsgNftTransfer) (*MsgNftTransferResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method NftTransfer not implemented") +} +func (UnimplementedMsgServer) mustEmbedUnimplementedMsgServer() {} + +// UnsafeMsgServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to MsgServer will +// result in compilation errors. +type UnsafeMsgServer interface { + mustEmbedUnimplementedMsgServer() +} + +func RegisterMsgServer(s grpc.ServiceRegistrar, srv MsgServer) { + s.RegisterService(&Msg_ServiceDesc, srv) +} + +func _Msg_NftTransfer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgNftTransfer) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).NftTransfer(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Msg_NftTransfer_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).NftTransfer(ctx, req.(*MsgNftTransfer)) + } + return interceptor(ctx, in, info, handler) +} + +// Msg_ServiceDesc is the grpc.ServiceDesc for Msg service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Msg_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "tibc.apps.nft_transfer.v1.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "NftTransfer", + Handler: _Msg_NftTransfer_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "tibc/apps/nft_transfer/v1/tx.proto", +} diff --git a/api/tibc/core/client/v1/client.pulsar.go b/api/tibc/core/client/v1/client.pulsar.go new file mode 100644 index 00000000..718d0dec --- /dev/null +++ b/api/tibc/core/client/v1/client.pulsar.go @@ -0,0 +1,5404 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package clientv1 + +import ( + fmt "fmt" + 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" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_IdentifiedClientState protoreflect.MessageDescriptor + fd_IdentifiedClientState_chain_name protoreflect.FieldDescriptor + fd_IdentifiedClientState_client_state protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_client_proto_init() + md_IdentifiedClientState = File_tibc_core_client_v1_client_proto.Messages().ByName("IdentifiedClientState") + fd_IdentifiedClientState_chain_name = md_IdentifiedClientState.Fields().ByName("chain_name") + fd_IdentifiedClientState_client_state = md_IdentifiedClientState.Fields().ByName("client_state") +} + +var _ protoreflect.Message = (*fastReflection_IdentifiedClientState)(nil) + +type fastReflection_IdentifiedClientState IdentifiedClientState + +func (x *IdentifiedClientState) ProtoReflect() protoreflect.Message { + return (*fastReflection_IdentifiedClientState)(x) +} + +func (x *IdentifiedClientState) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_client_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_IdentifiedClientState_messageType fastReflection_IdentifiedClientState_messageType +var _ protoreflect.MessageType = fastReflection_IdentifiedClientState_messageType{} + +type fastReflection_IdentifiedClientState_messageType struct{} + +func (x fastReflection_IdentifiedClientState_messageType) Zero() protoreflect.Message { + return (*fastReflection_IdentifiedClientState)(nil) +} +func (x fastReflection_IdentifiedClientState_messageType) New() protoreflect.Message { + return new(fastReflection_IdentifiedClientState) +} +func (x fastReflection_IdentifiedClientState_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_IdentifiedClientState +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_IdentifiedClientState) Descriptor() protoreflect.MessageDescriptor { + return md_IdentifiedClientState +} + +// 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_IdentifiedClientState) Type() protoreflect.MessageType { + return _fastReflection_IdentifiedClientState_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_IdentifiedClientState) New() protoreflect.Message { + return new(fastReflection_IdentifiedClientState) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_IdentifiedClientState) Interface() protoreflect.ProtoMessage { + return (*IdentifiedClientState)(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_IdentifiedClientState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ChainName != "" { + value := protoreflect.ValueOfString(x.ChainName) + if !f(fd_IdentifiedClientState_chain_name, value) { + return + } + } + if x.ClientState != nil { + value := protoreflect.ValueOfMessage(x.ClientState.ProtoReflect()) + if !f(fd_IdentifiedClientState_client_state, 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_IdentifiedClientState) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.IdentifiedClientState.chain_name": + return x.ChainName != "" + case "tibc.core.client.v1.IdentifiedClientState.client_state": + return x.ClientState != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.IdentifiedClientState")) + } + panic(fmt.Errorf("message tibc.core.client.v1.IdentifiedClientState 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_IdentifiedClientState) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.IdentifiedClientState.chain_name": + x.ChainName = "" + case "tibc.core.client.v1.IdentifiedClientState.client_state": + x.ClientState = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.IdentifiedClientState")) + } + panic(fmt.Errorf("message tibc.core.client.v1.IdentifiedClientState 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_IdentifiedClientState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.IdentifiedClientState.chain_name": + value := x.ChainName + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.IdentifiedClientState.client_state": + value := x.ClientState + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.IdentifiedClientState")) + } + panic(fmt.Errorf("message tibc.core.client.v1.IdentifiedClientState 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_IdentifiedClientState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.IdentifiedClientState.chain_name": + x.ChainName = value.Interface().(string) + case "tibc.core.client.v1.IdentifiedClientState.client_state": + x.ClientState = value.Message().Interface().(*anypb.Any) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.IdentifiedClientState")) + } + panic(fmt.Errorf("message tibc.core.client.v1.IdentifiedClientState 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_IdentifiedClientState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.IdentifiedClientState.client_state": + if x.ClientState == nil { + x.ClientState = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.ClientState.ProtoReflect()) + case "tibc.core.client.v1.IdentifiedClientState.chain_name": + panic(fmt.Errorf("field chain_name of message tibc.core.client.v1.IdentifiedClientState is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.IdentifiedClientState")) + } + panic(fmt.Errorf("message tibc.core.client.v1.IdentifiedClientState 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_IdentifiedClientState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.IdentifiedClientState.chain_name": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.IdentifiedClientState.client_state": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.IdentifiedClientState")) + } + panic(fmt.Errorf("message tibc.core.client.v1.IdentifiedClientState 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_IdentifiedClientState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.IdentifiedClientState", 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_IdentifiedClientState) 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_IdentifiedClientState) 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_IdentifiedClientState) 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_IdentifiedClientState) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*IdentifiedClientState) + 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.ChainName) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ClientState != nil { + l = options.Size(x.ClientState) + 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().(*IdentifiedClientState) + 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.ClientState != nil { + encoded, err := options.Marshal(x.ClientState) + 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.ChainName) > 0 { + i -= len(x.ChainName) + copy(dAtA[i:], x.ChainName) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainName))) + 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().(*IdentifiedClientState) + 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: IdentifiedClientState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: IdentifiedClientState: 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 ChainName", 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.ChainName = 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 ClientState", 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.ClientState == nil { + x.ClientState = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ClientState); 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 = (*_IdentifiedRelayers_2_list)(nil) + +type _IdentifiedRelayers_2_list struct { + list *[]string +} + +func (x *_IdentifiedRelayers_2_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_IdentifiedRelayers_2_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfString((*x.list)[i]) +} + +func (x *_IdentifiedRelayers_2_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_IdentifiedRelayers_2_list) Append(value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_IdentifiedRelayers_2_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message IdentifiedRelayers at list field Relayers as it is not of Message kind")) +} + +func (x *_IdentifiedRelayers_2_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_IdentifiedRelayers_2_list) NewElement() protoreflect.Value { + v := "" + return protoreflect.ValueOfString(v) +} + +func (x *_IdentifiedRelayers_2_list) IsValid() bool { + return x.list != nil +} + +var ( + md_IdentifiedRelayers protoreflect.MessageDescriptor + fd_IdentifiedRelayers_chain_name protoreflect.FieldDescriptor + fd_IdentifiedRelayers_relayers protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_client_proto_init() + md_IdentifiedRelayers = File_tibc_core_client_v1_client_proto.Messages().ByName("IdentifiedRelayers") + fd_IdentifiedRelayers_chain_name = md_IdentifiedRelayers.Fields().ByName("chain_name") + fd_IdentifiedRelayers_relayers = md_IdentifiedRelayers.Fields().ByName("relayers") +} + +var _ protoreflect.Message = (*fastReflection_IdentifiedRelayers)(nil) + +type fastReflection_IdentifiedRelayers IdentifiedRelayers + +func (x *IdentifiedRelayers) ProtoReflect() protoreflect.Message { + return (*fastReflection_IdentifiedRelayers)(x) +} + +func (x *IdentifiedRelayers) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_client_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_IdentifiedRelayers_messageType fastReflection_IdentifiedRelayers_messageType +var _ protoreflect.MessageType = fastReflection_IdentifiedRelayers_messageType{} + +type fastReflection_IdentifiedRelayers_messageType struct{} + +func (x fastReflection_IdentifiedRelayers_messageType) Zero() protoreflect.Message { + return (*fastReflection_IdentifiedRelayers)(nil) +} +func (x fastReflection_IdentifiedRelayers_messageType) New() protoreflect.Message { + return new(fastReflection_IdentifiedRelayers) +} +func (x fastReflection_IdentifiedRelayers_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_IdentifiedRelayers +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_IdentifiedRelayers) Descriptor() protoreflect.MessageDescriptor { + return md_IdentifiedRelayers +} + +// 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_IdentifiedRelayers) Type() protoreflect.MessageType { + return _fastReflection_IdentifiedRelayers_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_IdentifiedRelayers) New() protoreflect.Message { + return new(fastReflection_IdentifiedRelayers) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_IdentifiedRelayers) Interface() protoreflect.ProtoMessage { + return (*IdentifiedRelayers)(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_IdentifiedRelayers) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ChainName != "" { + value := protoreflect.ValueOfString(x.ChainName) + if !f(fd_IdentifiedRelayers_chain_name, value) { + return + } + } + if len(x.Relayers) != 0 { + value := protoreflect.ValueOfList(&_IdentifiedRelayers_2_list{list: &x.Relayers}) + if !f(fd_IdentifiedRelayers_relayers, 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_IdentifiedRelayers) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.IdentifiedRelayers.chain_name": + return x.ChainName != "" + case "tibc.core.client.v1.IdentifiedRelayers.relayers": + return len(x.Relayers) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.IdentifiedRelayers")) + } + panic(fmt.Errorf("message tibc.core.client.v1.IdentifiedRelayers 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_IdentifiedRelayers) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.IdentifiedRelayers.chain_name": + x.ChainName = "" + case "tibc.core.client.v1.IdentifiedRelayers.relayers": + x.Relayers = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.IdentifiedRelayers")) + } + panic(fmt.Errorf("message tibc.core.client.v1.IdentifiedRelayers 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_IdentifiedRelayers) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.IdentifiedRelayers.chain_name": + value := x.ChainName + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.IdentifiedRelayers.relayers": + if len(x.Relayers) == 0 { + return protoreflect.ValueOfList(&_IdentifiedRelayers_2_list{}) + } + listValue := &_IdentifiedRelayers_2_list{list: &x.Relayers} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.IdentifiedRelayers")) + } + panic(fmt.Errorf("message tibc.core.client.v1.IdentifiedRelayers 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_IdentifiedRelayers) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.IdentifiedRelayers.chain_name": + x.ChainName = value.Interface().(string) + case "tibc.core.client.v1.IdentifiedRelayers.relayers": + lv := value.List() + clv := lv.(*_IdentifiedRelayers_2_list) + x.Relayers = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.IdentifiedRelayers")) + } + panic(fmt.Errorf("message tibc.core.client.v1.IdentifiedRelayers 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_IdentifiedRelayers) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.IdentifiedRelayers.relayers": + if x.Relayers == nil { + x.Relayers = []string{} + } + value := &_IdentifiedRelayers_2_list{list: &x.Relayers} + return protoreflect.ValueOfList(value) + case "tibc.core.client.v1.IdentifiedRelayers.chain_name": + panic(fmt.Errorf("field chain_name of message tibc.core.client.v1.IdentifiedRelayers is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.IdentifiedRelayers")) + } + panic(fmt.Errorf("message tibc.core.client.v1.IdentifiedRelayers 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_IdentifiedRelayers) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.IdentifiedRelayers.chain_name": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.IdentifiedRelayers.relayers": + list := []string{} + return protoreflect.ValueOfList(&_IdentifiedRelayers_2_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.IdentifiedRelayers")) + } + panic(fmt.Errorf("message tibc.core.client.v1.IdentifiedRelayers 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_IdentifiedRelayers) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.IdentifiedRelayers", 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_IdentifiedRelayers) 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_IdentifiedRelayers) 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_IdentifiedRelayers) 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_IdentifiedRelayers) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*IdentifiedRelayers) + 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.ChainName) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.Relayers) > 0 { + for _, s := range x.Relayers { + l = len(s) + 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().(*IdentifiedRelayers) + 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.Relayers) > 0 { + for iNdEx := len(x.Relayers) - 1; iNdEx >= 0; iNdEx-- { + i -= len(x.Relayers[iNdEx]) + copy(dAtA[i:], x.Relayers[iNdEx]) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Relayers[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + if len(x.ChainName) > 0 { + i -= len(x.ChainName) + copy(dAtA[i:], x.ChainName) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainName))) + 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().(*IdentifiedRelayers) + 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: IdentifiedRelayers: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: IdentifiedRelayers: 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 ChainName", 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.ChainName = 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 Relayers", 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.Relayers = append(x.Relayers, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_ConsensusStateWithHeight protoreflect.MessageDescriptor + fd_ConsensusStateWithHeight_height protoreflect.FieldDescriptor + fd_ConsensusStateWithHeight_consensus_state protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_client_proto_init() + md_ConsensusStateWithHeight = File_tibc_core_client_v1_client_proto.Messages().ByName("ConsensusStateWithHeight") + fd_ConsensusStateWithHeight_height = md_ConsensusStateWithHeight.Fields().ByName("height") + fd_ConsensusStateWithHeight_consensus_state = md_ConsensusStateWithHeight.Fields().ByName("consensus_state") +} + +var _ protoreflect.Message = (*fastReflection_ConsensusStateWithHeight)(nil) + +type fastReflection_ConsensusStateWithHeight ConsensusStateWithHeight + +func (x *ConsensusStateWithHeight) ProtoReflect() protoreflect.Message { + return (*fastReflection_ConsensusStateWithHeight)(x) +} + +func (x *ConsensusStateWithHeight) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_client_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_ConsensusStateWithHeight_messageType fastReflection_ConsensusStateWithHeight_messageType +var _ protoreflect.MessageType = fastReflection_ConsensusStateWithHeight_messageType{} + +type fastReflection_ConsensusStateWithHeight_messageType struct{} + +func (x fastReflection_ConsensusStateWithHeight_messageType) Zero() protoreflect.Message { + return (*fastReflection_ConsensusStateWithHeight)(nil) +} +func (x fastReflection_ConsensusStateWithHeight_messageType) New() protoreflect.Message { + return new(fastReflection_ConsensusStateWithHeight) +} +func (x fastReflection_ConsensusStateWithHeight_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_ConsensusStateWithHeight +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_ConsensusStateWithHeight) Descriptor() protoreflect.MessageDescriptor { + return md_ConsensusStateWithHeight +} + +// 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_ConsensusStateWithHeight) Type() protoreflect.MessageType { + return _fastReflection_ConsensusStateWithHeight_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_ConsensusStateWithHeight) New() protoreflect.Message { + return new(fastReflection_ConsensusStateWithHeight) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_ConsensusStateWithHeight) Interface() protoreflect.ProtoMessage { + return (*ConsensusStateWithHeight)(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_ConsensusStateWithHeight) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Height != nil { + value := protoreflect.ValueOfMessage(x.Height.ProtoReflect()) + if !f(fd_ConsensusStateWithHeight_height, value) { + return + } + } + if x.ConsensusState != nil { + value := protoreflect.ValueOfMessage(x.ConsensusState.ProtoReflect()) + if !f(fd_ConsensusStateWithHeight_consensus_state, 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_ConsensusStateWithHeight) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.ConsensusStateWithHeight.height": + return x.Height != nil + case "tibc.core.client.v1.ConsensusStateWithHeight.consensus_state": + return x.ConsensusState != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.ConsensusStateWithHeight")) + } + panic(fmt.Errorf("message tibc.core.client.v1.ConsensusStateWithHeight 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_ConsensusStateWithHeight) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.ConsensusStateWithHeight.height": + x.Height = nil + case "tibc.core.client.v1.ConsensusStateWithHeight.consensus_state": + x.ConsensusState = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.ConsensusStateWithHeight")) + } + panic(fmt.Errorf("message tibc.core.client.v1.ConsensusStateWithHeight 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_ConsensusStateWithHeight) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.ConsensusStateWithHeight.height": + value := x.Height + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.client.v1.ConsensusStateWithHeight.consensus_state": + value := x.ConsensusState + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.ConsensusStateWithHeight")) + } + panic(fmt.Errorf("message tibc.core.client.v1.ConsensusStateWithHeight 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_ConsensusStateWithHeight) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.ConsensusStateWithHeight.height": + x.Height = value.Message().Interface().(*Height) + case "tibc.core.client.v1.ConsensusStateWithHeight.consensus_state": + x.ConsensusState = value.Message().Interface().(*anypb.Any) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.ConsensusStateWithHeight")) + } + panic(fmt.Errorf("message tibc.core.client.v1.ConsensusStateWithHeight 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_ConsensusStateWithHeight) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.ConsensusStateWithHeight.height": + if x.Height == nil { + x.Height = new(Height) + } + return protoreflect.ValueOfMessage(x.Height.ProtoReflect()) + case "tibc.core.client.v1.ConsensusStateWithHeight.consensus_state": + if x.ConsensusState == nil { + x.ConsensusState = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.ConsensusState.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.ConsensusStateWithHeight")) + } + panic(fmt.Errorf("message tibc.core.client.v1.ConsensusStateWithHeight 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_ConsensusStateWithHeight) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.ConsensusStateWithHeight.height": + m := new(Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.client.v1.ConsensusStateWithHeight.consensus_state": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.ConsensusStateWithHeight")) + } + panic(fmt.Errorf("message tibc.core.client.v1.ConsensusStateWithHeight 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_ConsensusStateWithHeight) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.ConsensusStateWithHeight", 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_ConsensusStateWithHeight) 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_ConsensusStateWithHeight) 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_ConsensusStateWithHeight) 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_ConsensusStateWithHeight) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*ConsensusStateWithHeight) + 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.Height != nil { + l = options.Size(x.Height) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ConsensusState != nil { + l = options.Size(x.ConsensusState) + 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().(*ConsensusStateWithHeight) + 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.ConsensusState != nil { + encoded, err := options.Marshal(x.ConsensusState) + 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 x.Height != nil { + encoded, err := options.Marshal(x.Height) + 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().(*ConsensusStateWithHeight) + 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: ConsensusStateWithHeight: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ConsensusStateWithHeight: 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 Height", 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.Height == nil { + x.Height = &Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Height); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ConsensusState", 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.ConsensusState == nil { + x.ConsensusState = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ConsensusState); 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 = (*_ClientConsensusStates_2_list)(nil) + +type _ClientConsensusStates_2_list struct { + list *[]*ConsensusStateWithHeight +} + +func (x *_ClientConsensusStates_2_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_ClientConsensusStates_2_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_ClientConsensusStates_2_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*ConsensusStateWithHeight) + (*x.list)[i] = concreteValue +} + +func (x *_ClientConsensusStates_2_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*ConsensusStateWithHeight) + *x.list = append(*x.list, concreteValue) +} + +func (x *_ClientConsensusStates_2_list) AppendMutable() protoreflect.Value { + v := new(ConsensusStateWithHeight) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_ClientConsensusStates_2_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_ClientConsensusStates_2_list) NewElement() protoreflect.Value { + v := new(ConsensusStateWithHeight) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_ClientConsensusStates_2_list) IsValid() bool { + return x.list != nil +} + +var ( + md_ClientConsensusStates protoreflect.MessageDescriptor + fd_ClientConsensusStates_chain_name protoreflect.FieldDescriptor + fd_ClientConsensusStates_consensus_states protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_client_proto_init() + md_ClientConsensusStates = File_tibc_core_client_v1_client_proto.Messages().ByName("ClientConsensusStates") + fd_ClientConsensusStates_chain_name = md_ClientConsensusStates.Fields().ByName("chain_name") + fd_ClientConsensusStates_consensus_states = md_ClientConsensusStates.Fields().ByName("consensus_states") +} + +var _ protoreflect.Message = (*fastReflection_ClientConsensusStates)(nil) + +type fastReflection_ClientConsensusStates ClientConsensusStates + +func (x *ClientConsensusStates) ProtoReflect() protoreflect.Message { + return (*fastReflection_ClientConsensusStates)(x) +} + +func (x *ClientConsensusStates) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_client_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_ClientConsensusStates_messageType fastReflection_ClientConsensusStates_messageType +var _ protoreflect.MessageType = fastReflection_ClientConsensusStates_messageType{} + +type fastReflection_ClientConsensusStates_messageType struct{} + +func (x fastReflection_ClientConsensusStates_messageType) Zero() protoreflect.Message { + return (*fastReflection_ClientConsensusStates)(nil) +} +func (x fastReflection_ClientConsensusStates_messageType) New() protoreflect.Message { + return new(fastReflection_ClientConsensusStates) +} +func (x fastReflection_ClientConsensusStates_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_ClientConsensusStates +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_ClientConsensusStates) Descriptor() protoreflect.MessageDescriptor { + return md_ClientConsensusStates +} + +// 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_ClientConsensusStates) Type() protoreflect.MessageType { + return _fastReflection_ClientConsensusStates_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_ClientConsensusStates) New() protoreflect.Message { + return new(fastReflection_ClientConsensusStates) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_ClientConsensusStates) Interface() protoreflect.ProtoMessage { + return (*ClientConsensusStates)(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_ClientConsensusStates) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ChainName != "" { + value := protoreflect.ValueOfString(x.ChainName) + if !f(fd_ClientConsensusStates_chain_name, value) { + return + } + } + if len(x.ConsensusStates) != 0 { + value := protoreflect.ValueOfList(&_ClientConsensusStates_2_list{list: &x.ConsensusStates}) + if !f(fd_ClientConsensusStates_consensus_states, 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_ClientConsensusStates) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.ClientConsensusStates.chain_name": + return x.ChainName != "" + case "tibc.core.client.v1.ClientConsensusStates.consensus_states": + return len(x.ConsensusStates) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.ClientConsensusStates")) + } + panic(fmt.Errorf("message tibc.core.client.v1.ClientConsensusStates 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_ClientConsensusStates) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.ClientConsensusStates.chain_name": + x.ChainName = "" + case "tibc.core.client.v1.ClientConsensusStates.consensus_states": + x.ConsensusStates = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.ClientConsensusStates")) + } + panic(fmt.Errorf("message tibc.core.client.v1.ClientConsensusStates 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_ClientConsensusStates) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.ClientConsensusStates.chain_name": + value := x.ChainName + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.ClientConsensusStates.consensus_states": + if len(x.ConsensusStates) == 0 { + return protoreflect.ValueOfList(&_ClientConsensusStates_2_list{}) + } + listValue := &_ClientConsensusStates_2_list{list: &x.ConsensusStates} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.ClientConsensusStates")) + } + panic(fmt.Errorf("message tibc.core.client.v1.ClientConsensusStates 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_ClientConsensusStates) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.ClientConsensusStates.chain_name": + x.ChainName = value.Interface().(string) + case "tibc.core.client.v1.ClientConsensusStates.consensus_states": + lv := value.List() + clv := lv.(*_ClientConsensusStates_2_list) + x.ConsensusStates = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.ClientConsensusStates")) + } + panic(fmt.Errorf("message tibc.core.client.v1.ClientConsensusStates 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_ClientConsensusStates) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.ClientConsensusStates.consensus_states": + if x.ConsensusStates == nil { + x.ConsensusStates = []*ConsensusStateWithHeight{} + } + value := &_ClientConsensusStates_2_list{list: &x.ConsensusStates} + return protoreflect.ValueOfList(value) + case "tibc.core.client.v1.ClientConsensusStates.chain_name": + panic(fmt.Errorf("field chain_name of message tibc.core.client.v1.ClientConsensusStates is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.ClientConsensusStates")) + } + panic(fmt.Errorf("message tibc.core.client.v1.ClientConsensusStates 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_ClientConsensusStates) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.ClientConsensusStates.chain_name": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.ClientConsensusStates.consensus_states": + list := []*ConsensusStateWithHeight{} + return protoreflect.ValueOfList(&_ClientConsensusStates_2_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.ClientConsensusStates")) + } + panic(fmt.Errorf("message tibc.core.client.v1.ClientConsensusStates 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_ClientConsensusStates) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.ClientConsensusStates", 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_ClientConsensusStates) 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_ClientConsensusStates) 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_ClientConsensusStates) 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_ClientConsensusStates) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*ClientConsensusStates) + 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.ChainName) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.ConsensusStates) > 0 { + for _, e := range x.ConsensusStates { + 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().(*ClientConsensusStates) + 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.ConsensusStates) > 0 { + for iNdEx := len(x.ConsensusStates) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.ConsensusStates[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] = 0x12 + } + } + if len(x.ChainName) > 0 { + i -= len(x.ChainName) + copy(dAtA[i:], x.ChainName) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainName))) + 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().(*ClientConsensusStates) + 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: ClientConsensusStates: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ClientConsensusStates: 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 ChainName", 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.ChainName = 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 ConsensusStates", 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.ConsensusStates = append(x.ConsensusStates, &ConsensusStateWithHeight{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ConsensusStates[len(x.ConsensusStates)-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_CreateClientProposal protoreflect.MessageDescriptor + fd_CreateClientProposal_title protoreflect.FieldDescriptor + fd_CreateClientProposal_description protoreflect.FieldDescriptor + fd_CreateClientProposal_chain_name protoreflect.FieldDescriptor + fd_CreateClientProposal_client_state protoreflect.FieldDescriptor + fd_CreateClientProposal_consensus_state protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_client_proto_init() + md_CreateClientProposal = File_tibc_core_client_v1_client_proto.Messages().ByName("CreateClientProposal") + fd_CreateClientProposal_title = md_CreateClientProposal.Fields().ByName("title") + fd_CreateClientProposal_description = md_CreateClientProposal.Fields().ByName("description") + fd_CreateClientProposal_chain_name = md_CreateClientProposal.Fields().ByName("chain_name") + fd_CreateClientProposal_client_state = md_CreateClientProposal.Fields().ByName("client_state") + fd_CreateClientProposal_consensus_state = md_CreateClientProposal.Fields().ByName("consensus_state") +} + +var _ protoreflect.Message = (*fastReflection_CreateClientProposal)(nil) + +type fastReflection_CreateClientProposal CreateClientProposal + +func (x *CreateClientProposal) ProtoReflect() protoreflect.Message { + return (*fastReflection_CreateClientProposal)(x) +} + +func (x *CreateClientProposal) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_client_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_CreateClientProposal_messageType fastReflection_CreateClientProposal_messageType +var _ protoreflect.MessageType = fastReflection_CreateClientProposal_messageType{} + +type fastReflection_CreateClientProposal_messageType struct{} + +func (x fastReflection_CreateClientProposal_messageType) Zero() protoreflect.Message { + return (*fastReflection_CreateClientProposal)(nil) +} +func (x fastReflection_CreateClientProposal_messageType) New() protoreflect.Message { + return new(fastReflection_CreateClientProposal) +} +func (x fastReflection_CreateClientProposal_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_CreateClientProposal +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_CreateClientProposal) Descriptor() protoreflect.MessageDescriptor { + return md_CreateClientProposal +} + +// 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_CreateClientProposal) Type() protoreflect.MessageType { + return _fastReflection_CreateClientProposal_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_CreateClientProposal) New() protoreflect.Message { + return new(fastReflection_CreateClientProposal) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_CreateClientProposal) Interface() protoreflect.ProtoMessage { + return (*CreateClientProposal)(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_CreateClientProposal) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Title != "" { + value := protoreflect.ValueOfString(x.Title) + if !f(fd_CreateClientProposal_title, value) { + return + } + } + if x.Description != "" { + value := protoreflect.ValueOfString(x.Description) + if !f(fd_CreateClientProposal_description, value) { + return + } + } + if x.ChainName != "" { + value := protoreflect.ValueOfString(x.ChainName) + if !f(fd_CreateClientProposal_chain_name, value) { + return + } + } + if x.ClientState != nil { + value := protoreflect.ValueOfMessage(x.ClientState.ProtoReflect()) + if !f(fd_CreateClientProposal_client_state, value) { + return + } + } + if x.ConsensusState != nil { + value := protoreflect.ValueOfMessage(x.ConsensusState.ProtoReflect()) + if !f(fd_CreateClientProposal_consensus_state, 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_CreateClientProposal) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.CreateClientProposal.title": + return x.Title != "" + case "tibc.core.client.v1.CreateClientProposal.description": + return x.Description != "" + case "tibc.core.client.v1.CreateClientProposal.chain_name": + return x.ChainName != "" + case "tibc.core.client.v1.CreateClientProposal.client_state": + return x.ClientState != nil + case "tibc.core.client.v1.CreateClientProposal.consensus_state": + return x.ConsensusState != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.CreateClientProposal")) + } + panic(fmt.Errorf("message tibc.core.client.v1.CreateClientProposal 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_CreateClientProposal) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.CreateClientProposal.title": + x.Title = "" + case "tibc.core.client.v1.CreateClientProposal.description": + x.Description = "" + case "tibc.core.client.v1.CreateClientProposal.chain_name": + x.ChainName = "" + case "tibc.core.client.v1.CreateClientProposal.client_state": + x.ClientState = nil + case "tibc.core.client.v1.CreateClientProposal.consensus_state": + x.ConsensusState = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.CreateClientProposal")) + } + panic(fmt.Errorf("message tibc.core.client.v1.CreateClientProposal 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_CreateClientProposal) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.CreateClientProposal.title": + value := x.Title + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.CreateClientProposal.description": + value := x.Description + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.CreateClientProposal.chain_name": + value := x.ChainName + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.CreateClientProposal.client_state": + value := x.ClientState + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.client.v1.CreateClientProposal.consensus_state": + value := x.ConsensusState + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.CreateClientProposal")) + } + panic(fmt.Errorf("message tibc.core.client.v1.CreateClientProposal 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_CreateClientProposal) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.CreateClientProposal.title": + x.Title = value.Interface().(string) + case "tibc.core.client.v1.CreateClientProposal.description": + x.Description = value.Interface().(string) + case "tibc.core.client.v1.CreateClientProposal.chain_name": + x.ChainName = value.Interface().(string) + case "tibc.core.client.v1.CreateClientProposal.client_state": + x.ClientState = value.Message().Interface().(*anypb.Any) + case "tibc.core.client.v1.CreateClientProposal.consensus_state": + x.ConsensusState = value.Message().Interface().(*anypb.Any) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.CreateClientProposal")) + } + panic(fmt.Errorf("message tibc.core.client.v1.CreateClientProposal 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_CreateClientProposal) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.CreateClientProposal.client_state": + if x.ClientState == nil { + x.ClientState = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.ClientState.ProtoReflect()) + case "tibc.core.client.v1.CreateClientProposal.consensus_state": + if x.ConsensusState == nil { + x.ConsensusState = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.ConsensusState.ProtoReflect()) + case "tibc.core.client.v1.CreateClientProposal.title": + panic(fmt.Errorf("field title of message tibc.core.client.v1.CreateClientProposal is not mutable")) + case "tibc.core.client.v1.CreateClientProposal.description": + panic(fmt.Errorf("field description of message tibc.core.client.v1.CreateClientProposal is not mutable")) + case "tibc.core.client.v1.CreateClientProposal.chain_name": + panic(fmt.Errorf("field chain_name of message tibc.core.client.v1.CreateClientProposal is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.CreateClientProposal")) + } + panic(fmt.Errorf("message tibc.core.client.v1.CreateClientProposal 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_CreateClientProposal) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.CreateClientProposal.title": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.CreateClientProposal.description": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.CreateClientProposal.chain_name": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.CreateClientProposal.client_state": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.client.v1.CreateClientProposal.consensus_state": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.CreateClientProposal")) + } + panic(fmt.Errorf("message tibc.core.client.v1.CreateClientProposal 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_CreateClientProposal) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.CreateClientProposal", 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_CreateClientProposal) 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_CreateClientProposal) 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_CreateClientProposal) 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_CreateClientProposal) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*CreateClientProposal) + 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.Title) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Description) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.ChainName) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ClientState != nil { + l = options.Size(x.ClientState) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ConsensusState != nil { + l = options.Size(x.ConsensusState) + 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().(*CreateClientProposal) + 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.ConsensusState != nil { + encoded, err := options.Marshal(x.ConsensusState) + 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] = 0x2a + } + if x.ClientState != nil { + encoded, err := options.Marshal(x.ClientState) + 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] = 0x22 + } + if len(x.ChainName) > 0 { + i -= len(x.ChainName) + copy(dAtA[i:], x.ChainName) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainName))) + i-- + dAtA[i] = 0x1a + } + if len(x.Description) > 0 { + i -= len(x.Description) + copy(dAtA[i:], x.Description) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Description))) + i-- + dAtA[i] = 0x12 + } + if len(x.Title) > 0 { + i -= len(x.Title) + copy(dAtA[i:], x.Title) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Title))) + 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().(*CreateClientProposal) + 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: CreateClientProposal: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: CreateClientProposal: 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 Title", 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.Title = 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 Description", 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.Description = 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 ChainName", 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.ChainName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ClientState", 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.ClientState == nil { + x.ClientState = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ClientState); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ConsensusState", 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.ConsensusState == nil { + x.ConsensusState = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ConsensusState); 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_UpgradeClientProposal protoreflect.MessageDescriptor + fd_UpgradeClientProposal_title protoreflect.FieldDescriptor + fd_UpgradeClientProposal_description protoreflect.FieldDescriptor + fd_UpgradeClientProposal_chain_name protoreflect.FieldDescriptor + fd_UpgradeClientProposal_client_state protoreflect.FieldDescriptor + fd_UpgradeClientProposal_consensus_state protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_client_proto_init() + md_UpgradeClientProposal = File_tibc_core_client_v1_client_proto.Messages().ByName("UpgradeClientProposal") + fd_UpgradeClientProposal_title = md_UpgradeClientProposal.Fields().ByName("title") + fd_UpgradeClientProposal_description = md_UpgradeClientProposal.Fields().ByName("description") + fd_UpgradeClientProposal_chain_name = md_UpgradeClientProposal.Fields().ByName("chain_name") + fd_UpgradeClientProposal_client_state = md_UpgradeClientProposal.Fields().ByName("client_state") + fd_UpgradeClientProposal_consensus_state = md_UpgradeClientProposal.Fields().ByName("consensus_state") +} + +var _ protoreflect.Message = (*fastReflection_UpgradeClientProposal)(nil) + +type fastReflection_UpgradeClientProposal UpgradeClientProposal + +func (x *UpgradeClientProposal) ProtoReflect() protoreflect.Message { + return (*fastReflection_UpgradeClientProposal)(x) +} + +func (x *UpgradeClientProposal) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_client_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_UpgradeClientProposal_messageType fastReflection_UpgradeClientProposal_messageType +var _ protoreflect.MessageType = fastReflection_UpgradeClientProposal_messageType{} + +type fastReflection_UpgradeClientProposal_messageType struct{} + +func (x fastReflection_UpgradeClientProposal_messageType) Zero() protoreflect.Message { + return (*fastReflection_UpgradeClientProposal)(nil) +} +func (x fastReflection_UpgradeClientProposal_messageType) New() protoreflect.Message { + return new(fastReflection_UpgradeClientProposal) +} +func (x fastReflection_UpgradeClientProposal_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_UpgradeClientProposal +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_UpgradeClientProposal) Descriptor() protoreflect.MessageDescriptor { + return md_UpgradeClientProposal +} + +// 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_UpgradeClientProposal) Type() protoreflect.MessageType { + return _fastReflection_UpgradeClientProposal_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_UpgradeClientProposal) New() protoreflect.Message { + return new(fastReflection_UpgradeClientProposal) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_UpgradeClientProposal) Interface() protoreflect.ProtoMessage { + return (*UpgradeClientProposal)(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_UpgradeClientProposal) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Title != "" { + value := protoreflect.ValueOfString(x.Title) + if !f(fd_UpgradeClientProposal_title, value) { + return + } + } + if x.Description != "" { + value := protoreflect.ValueOfString(x.Description) + if !f(fd_UpgradeClientProposal_description, value) { + return + } + } + if x.ChainName != "" { + value := protoreflect.ValueOfString(x.ChainName) + if !f(fd_UpgradeClientProposal_chain_name, value) { + return + } + } + if x.ClientState != nil { + value := protoreflect.ValueOfMessage(x.ClientState.ProtoReflect()) + if !f(fd_UpgradeClientProposal_client_state, value) { + return + } + } + if x.ConsensusState != nil { + value := protoreflect.ValueOfMessage(x.ConsensusState.ProtoReflect()) + if !f(fd_UpgradeClientProposal_consensus_state, 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_UpgradeClientProposal) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.UpgradeClientProposal.title": + return x.Title != "" + case "tibc.core.client.v1.UpgradeClientProposal.description": + return x.Description != "" + case "tibc.core.client.v1.UpgradeClientProposal.chain_name": + return x.ChainName != "" + case "tibc.core.client.v1.UpgradeClientProposal.client_state": + return x.ClientState != nil + case "tibc.core.client.v1.UpgradeClientProposal.consensus_state": + return x.ConsensusState != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.UpgradeClientProposal")) + } + panic(fmt.Errorf("message tibc.core.client.v1.UpgradeClientProposal 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_UpgradeClientProposal) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.UpgradeClientProposal.title": + x.Title = "" + case "tibc.core.client.v1.UpgradeClientProposal.description": + x.Description = "" + case "tibc.core.client.v1.UpgradeClientProposal.chain_name": + x.ChainName = "" + case "tibc.core.client.v1.UpgradeClientProposal.client_state": + x.ClientState = nil + case "tibc.core.client.v1.UpgradeClientProposal.consensus_state": + x.ConsensusState = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.UpgradeClientProposal")) + } + panic(fmt.Errorf("message tibc.core.client.v1.UpgradeClientProposal 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_UpgradeClientProposal) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.UpgradeClientProposal.title": + value := x.Title + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.UpgradeClientProposal.description": + value := x.Description + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.UpgradeClientProposal.chain_name": + value := x.ChainName + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.UpgradeClientProposal.client_state": + value := x.ClientState + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.client.v1.UpgradeClientProposal.consensus_state": + value := x.ConsensusState + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.UpgradeClientProposal")) + } + panic(fmt.Errorf("message tibc.core.client.v1.UpgradeClientProposal 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_UpgradeClientProposal) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.UpgradeClientProposal.title": + x.Title = value.Interface().(string) + case "tibc.core.client.v1.UpgradeClientProposal.description": + x.Description = value.Interface().(string) + case "tibc.core.client.v1.UpgradeClientProposal.chain_name": + x.ChainName = value.Interface().(string) + case "tibc.core.client.v1.UpgradeClientProposal.client_state": + x.ClientState = value.Message().Interface().(*anypb.Any) + case "tibc.core.client.v1.UpgradeClientProposal.consensus_state": + x.ConsensusState = value.Message().Interface().(*anypb.Any) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.UpgradeClientProposal")) + } + panic(fmt.Errorf("message tibc.core.client.v1.UpgradeClientProposal 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_UpgradeClientProposal) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.UpgradeClientProposal.client_state": + if x.ClientState == nil { + x.ClientState = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.ClientState.ProtoReflect()) + case "tibc.core.client.v1.UpgradeClientProposal.consensus_state": + if x.ConsensusState == nil { + x.ConsensusState = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.ConsensusState.ProtoReflect()) + case "tibc.core.client.v1.UpgradeClientProposal.title": + panic(fmt.Errorf("field title of message tibc.core.client.v1.UpgradeClientProposal is not mutable")) + case "tibc.core.client.v1.UpgradeClientProposal.description": + panic(fmt.Errorf("field description of message tibc.core.client.v1.UpgradeClientProposal is not mutable")) + case "tibc.core.client.v1.UpgradeClientProposal.chain_name": + panic(fmt.Errorf("field chain_name of message tibc.core.client.v1.UpgradeClientProposal is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.UpgradeClientProposal")) + } + panic(fmt.Errorf("message tibc.core.client.v1.UpgradeClientProposal 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_UpgradeClientProposal) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.UpgradeClientProposal.title": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.UpgradeClientProposal.description": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.UpgradeClientProposal.chain_name": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.UpgradeClientProposal.client_state": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.client.v1.UpgradeClientProposal.consensus_state": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.UpgradeClientProposal")) + } + panic(fmt.Errorf("message tibc.core.client.v1.UpgradeClientProposal 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_UpgradeClientProposal) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.UpgradeClientProposal", 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_UpgradeClientProposal) 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_UpgradeClientProposal) 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_UpgradeClientProposal) 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_UpgradeClientProposal) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*UpgradeClientProposal) + 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.Title) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Description) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.ChainName) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ClientState != nil { + l = options.Size(x.ClientState) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ConsensusState != nil { + l = options.Size(x.ConsensusState) + 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().(*UpgradeClientProposal) + 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.ConsensusState != nil { + encoded, err := options.Marshal(x.ConsensusState) + 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] = 0x2a + } + if x.ClientState != nil { + encoded, err := options.Marshal(x.ClientState) + 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] = 0x22 + } + if len(x.ChainName) > 0 { + i -= len(x.ChainName) + copy(dAtA[i:], x.ChainName) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainName))) + i-- + dAtA[i] = 0x1a + } + if len(x.Description) > 0 { + i -= len(x.Description) + copy(dAtA[i:], x.Description) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Description))) + i-- + dAtA[i] = 0x12 + } + if len(x.Title) > 0 { + i -= len(x.Title) + copy(dAtA[i:], x.Title) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Title))) + 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().(*UpgradeClientProposal) + 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: UpgradeClientProposal: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: UpgradeClientProposal: 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 Title", 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.Title = 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 Description", 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.Description = 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 ChainName", 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.ChainName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ClientState", 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.ClientState == nil { + x.ClientState = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ClientState); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ConsensusState", 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.ConsensusState == nil { + x.ConsensusState = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ConsensusState); 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 = (*_RegisterRelayerProposal_4_list)(nil) + +type _RegisterRelayerProposal_4_list struct { + list *[]string +} + +func (x *_RegisterRelayerProposal_4_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_RegisterRelayerProposal_4_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfString((*x.list)[i]) +} + +func (x *_RegisterRelayerProposal_4_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_RegisterRelayerProposal_4_list) Append(value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_RegisterRelayerProposal_4_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message RegisterRelayerProposal at list field Relayers as it is not of Message kind")) +} + +func (x *_RegisterRelayerProposal_4_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_RegisterRelayerProposal_4_list) NewElement() protoreflect.Value { + v := "" + return protoreflect.ValueOfString(v) +} + +func (x *_RegisterRelayerProposal_4_list) IsValid() bool { + return x.list != nil +} + +var ( + md_RegisterRelayerProposal protoreflect.MessageDescriptor + fd_RegisterRelayerProposal_title protoreflect.FieldDescriptor + fd_RegisterRelayerProposal_description protoreflect.FieldDescriptor + fd_RegisterRelayerProposal_chain_name protoreflect.FieldDescriptor + fd_RegisterRelayerProposal_relayers protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_client_proto_init() + md_RegisterRelayerProposal = File_tibc_core_client_v1_client_proto.Messages().ByName("RegisterRelayerProposal") + fd_RegisterRelayerProposal_title = md_RegisterRelayerProposal.Fields().ByName("title") + fd_RegisterRelayerProposal_description = md_RegisterRelayerProposal.Fields().ByName("description") + fd_RegisterRelayerProposal_chain_name = md_RegisterRelayerProposal.Fields().ByName("chain_name") + fd_RegisterRelayerProposal_relayers = md_RegisterRelayerProposal.Fields().ByName("relayers") +} + +var _ protoreflect.Message = (*fastReflection_RegisterRelayerProposal)(nil) + +type fastReflection_RegisterRelayerProposal RegisterRelayerProposal + +func (x *RegisterRelayerProposal) ProtoReflect() protoreflect.Message { + return (*fastReflection_RegisterRelayerProposal)(x) +} + +func (x *RegisterRelayerProposal) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_client_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_RegisterRelayerProposal_messageType fastReflection_RegisterRelayerProposal_messageType +var _ protoreflect.MessageType = fastReflection_RegisterRelayerProposal_messageType{} + +type fastReflection_RegisterRelayerProposal_messageType struct{} + +func (x fastReflection_RegisterRelayerProposal_messageType) Zero() protoreflect.Message { + return (*fastReflection_RegisterRelayerProposal)(nil) +} +func (x fastReflection_RegisterRelayerProposal_messageType) New() protoreflect.Message { + return new(fastReflection_RegisterRelayerProposal) +} +func (x fastReflection_RegisterRelayerProposal_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_RegisterRelayerProposal +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_RegisterRelayerProposal) Descriptor() protoreflect.MessageDescriptor { + return md_RegisterRelayerProposal +} + +// 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_RegisterRelayerProposal) Type() protoreflect.MessageType { + return _fastReflection_RegisterRelayerProposal_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_RegisterRelayerProposal) New() protoreflect.Message { + return new(fastReflection_RegisterRelayerProposal) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_RegisterRelayerProposal) Interface() protoreflect.ProtoMessage { + return (*RegisterRelayerProposal)(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_RegisterRelayerProposal) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Title != "" { + value := protoreflect.ValueOfString(x.Title) + if !f(fd_RegisterRelayerProposal_title, value) { + return + } + } + if x.Description != "" { + value := protoreflect.ValueOfString(x.Description) + if !f(fd_RegisterRelayerProposal_description, value) { + return + } + } + if x.ChainName != "" { + value := protoreflect.ValueOfString(x.ChainName) + if !f(fd_RegisterRelayerProposal_chain_name, value) { + return + } + } + if len(x.Relayers) != 0 { + value := protoreflect.ValueOfList(&_RegisterRelayerProposal_4_list{list: &x.Relayers}) + if !f(fd_RegisterRelayerProposal_relayers, 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_RegisterRelayerProposal) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.RegisterRelayerProposal.title": + return x.Title != "" + case "tibc.core.client.v1.RegisterRelayerProposal.description": + return x.Description != "" + case "tibc.core.client.v1.RegisterRelayerProposal.chain_name": + return x.ChainName != "" + case "tibc.core.client.v1.RegisterRelayerProposal.relayers": + return len(x.Relayers) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.RegisterRelayerProposal")) + } + panic(fmt.Errorf("message tibc.core.client.v1.RegisterRelayerProposal 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_RegisterRelayerProposal) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.RegisterRelayerProposal.title": + x.Title = "" + case "tibc.core.client.v1.RegisterRelayerProposal.description": + x.Description = "" + case "tibc.core.client.v1.RegisterRelayerProposal.chain_name": + x.ChainName = "" + case "tibc.core.client.v1.RegisterRelayerProposal.relayers": + x.Relayers = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.RegisterRelayerProposal")) + } + panic(fmt.Errorf("message tibc.core.client.v1.RegisterRelayerProposal 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_RegisterRelayerProposal) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.RegisterRelayerProposal.title": + value := x.Title + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.RegisterRelayerProposal.description": + value := x.Description + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.RegisterRelayerProposal.chain_name": + value := x.ChainName + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.RegisterRelayerProposal.relayers": + if len(x.Relayers) == 0 { + return protoreflect.ValueOfList(&_RegisterRelayerProposal_4_list{}) + } + listValue := &_RegisterRelayerProposal_4_list{list: &x.Relayers} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.RegisterRelayerProposal")) + } + panic(fmt.Errorf("message tibc.core.client.v1.RegisterRelayerProposal 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_RegisterRelayerProposal) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.RegisterRelayerProposal.title": + x.Title = value.Interface().(string) + case "tibc.core.client.v1.RegisterRelayerProposal.description": + x.Description = value.Interface().(string) + case "tibc.core.client.v1.RegisterRelayerProposal.chain_name": + x.ChainName = value.Interface().(string) + case "tibc.core.client.v1.RegisterRelayerProposal.relayers": + lv := value.List() + clv := lv.(*_RegisterRelayerProposal_4_list) + x.Relayers = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.RegisterRelayerProposal")) + } + panic(fmt.Errorf("message tibc.core.client.v1.RegisterRelayerProposal 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_RegisterRelayerProposal) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.RegisterRelayerProposal.relayers": + if x.Relayers == nil { + x.Relayers = []string{} + } + value := &_RegisterRelayerProposal_4_list{list: &x.Relayers} + return protoreflect.ValueOfList(value) + case "tibc.core.client.v1.RegisterRelayerProposal.title": + panic(fmt.Errorf("field title of message tibc.core.client.v1.RegisterRelayerProposal is not mutable")) + case "tibc.core.client.v1.RegisterRelayerProposal.description": + panic(fmt.Errorf("field description of message tibc.core.client.v1.RegisterRelayerProposal is not mutable")) + case "tibc.core.client.v1.RegisterRelayerProposal.chain_name": + panic(fmt.Errorf("field chain_name of message tibc.core.client.v1.RegisterRelayerProposal is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.RegisterRelayerProposal")) + } + panic(fmt.Errorf("message tibc.core.client.v1.RegisterRelayerProposal 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_RegisterRelayerProposal) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.RegisterRelayerProposal.title": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.RegisterRelayerProposal.description": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.RegisterRelayerProposal.chain_name": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.RegisterRelayerProposal.relayers": + list := []string{} + return protoreflect.ValueOfList(&_RegisterRelayerProposal_4_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.RegisterRelayerProposal")) + } + panic(fmt.Errorf("message tibc.core.client.v1.RegisterRelayerProposal 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_RegisterRelayerProposal) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.RegisterRelayerProposal", 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_RegisterRelayerProposal) 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_RegisterRelayerProposal) 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_RegisterRelayerProposal) 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_RegisterRelayerProposal) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*RegisterRelayerProposal) + 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.Title) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Description) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.ChainName) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.Relayers) > 0 { + for _, s := range x.Relayers { + l = len(s) + 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().(*RegisterRelayerProposal) + 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.Relayers) > 0 { + for iNdEx := len(x.Relayers) - 1; iNdEx >= 0; iNdEx-- { + i -= len(x.Relayers[iNdEx]) + copy(dAtA[i:], x.Relayers[iNdEx]) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Relayers[iNdEx]))) + i-- + dAtA[i] = 0x22 + } + } + if len(x.ChainName) > 0 { + i -= len(x.ChainName) + copy(dAtA[i:], x.ChainName) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainName))) + i-- + dAtA[i] = 0x1a + } + if len(x.Description) > 0 { + i -= len(x.Description) + copy(dAtA[i:], x.Description) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Description))) + i-- + dAtA[i] = 0x12 + } + if len(x.Title) > 0 { + i -= len(x.Title) + copy(dAtA[i:], x.Title) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Title))) + 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().(*RegisterRelayerProposal) + 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: RegisterRelayerProposal: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: RegisterRelayerProposal: 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 Title", 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.Title = 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 Description", 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.Description = 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 ChainName", 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.ChainName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Relayers", 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.Relayers = append(x.Relayers, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_Height protoreflect.MessageDescriptor + fd_Height_revision_number protoreflect.FieldDescriptor + fd_Height_revision_height protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_client_proto_init() + md_Height = File_tibc_core_client_v1_client_proto.Messages().ByName("Height") + fd_Height_revision_number = md_Height.Fields().ByName("revision_number") + fd_Height_revision_height = md_Height.Fields().ByName("revision_height") +} + +var _ protoreflect.Message = (*fastReflection_Height)(nil) + +type fastReflection_Height Height + +func (x *Height) ProtoReflect() protoreflect.Message { + return (*fastReflection_Height)(x) +} + +func (x *Height) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_client_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_Height_messageType fastReflection_Height_messageType +var _ protoreflect.MessageType = fastReflection_Height_messageType{} + +type fastReflection_Height_messageType struct{} + +func (x fastReflection_Height_messageType) Zero() protoreflect.Message { + return (*fastReflection_Height)(nil) +} +func (x fastReflection_Height_messageType) New() protoreflect.Message { + return new(fastReflection_Height) +} +func (x fastReflection_Height_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Height +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Height) Descriptor() protoreflect.MessageDescriptor { + return md_Height +} + +// 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_Height) Type() protoreflect.MessageType { + return _fastReflection_Height_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Height) New() protoreflect.Message { + return new(fastReflection_Height) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Height) Interface() protoreflect.ProtoMessage { + return (*Height)(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_Height) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.RevisionNumber != uint64(0) { + value := protoreflect.ValueOfUint64(x.RevisionNumber) + if !f(fd_Height_revision_number, value) { + return + } + } + if x.RevisionHeight != uint64(0) { + value := protoreflect.ValueOfUint64(x.RevisionHeight) + if !f(fd_Height_revision_height, 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_Height) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.Height.revision_number": + return x.RevisionNumber != uint64(0) + case "tibc.core.client.v1.Height.revision_height": + return x.RevisionHeight != uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.Height")) + } + panic(fmt.Errorf("message tibc.core.client.v1.Height 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_Height) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.Height.revision_number": + x.RevisionNumber = uint64(0) + case "tibc.core.client.v1.Height.revision_height": + x.RevisionHeight = uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.Height")) + } + panic(fmt.Errorf("message tibc.core.client.v1.Height 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_Height) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.Height.revision_number": + value := x.RevisionNumber + return protoreflect.ValueOfUint64(value) + case "tibc.core.client.v1.Height.revision_height": + value := x.RevisionHeight + return protoreflect.ValueOfUint64(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.Height")) + } + panic(fmt.Errorf("message tibc.core.client.v1.Height 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_Height) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.Height.revision_number": + x.RevisionNumber = value.Uint() + case "tibc.core.client.v1.Height.revision_height": + x.RevisionHeight = value.Uint() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.Height")) + } + panic(fmt.Errorf("message tibc.core.client.v1.Height 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_Height) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.Height.revision_number": + panic(fmt.Errorf("field revision_number of message tibc.core.client.v1.Height is not mutable")) + case "tibc.core.client.v1.Height.revision_height": + panic(fmt.Errorf("field revision_height of message tibc.core.client.v1.Height is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.Height")) + } + panic(fmt.Errorf("message tibc.core.client.v1.Height 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_Height) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.Height.revision_number": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.core.client.v1.Height.revision_height": + return protoreflect.ValueOfUint64(uint64(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.Height")) + } + panic(fmt.Errorf("message tibc.core.client.v1.Height 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_Height) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.Height", 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_Height) 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_Height) 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_Height) 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_Height) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Height) + 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.RevisionNumber != 0 { + n += 1 + runtime.Sov(uint64(x.RevisionNumber)) + } + if x.RevisionHeight != 0 { + n += 1 + runtime.Sov(uint64(x.RevisionHeight)) + } + 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().(*Height) + 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.RevisionHeight != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.RevisionHeight)) + i-- + dAtA[i] = 0x10 + } + if x.RevisionNumber != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.RevisionNumber)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*Height) + 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: Height: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Height: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RevisionNumber", wireType) + } + x.RevisionNumber = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.RevisionNumber |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RevisionHeight", wireType) + } + x.RevisionHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.RevisionHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: tibc/core/client/v1/client.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) +) + +// IdentifiedClientState defines a client state with an additional client +// identifier field. +type IdentifiedClientState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // client identifier + ChainName string `protobuf:"bytes,1,opt,name=chain_name,json=chainName,proto3" json:"chain_name,omitempty"` + // client state + ClientState *anypb.Any `protobuf:"bytes,2,opt,name=client_state,json=clientState,proto3" json:"client_state,omitempty"` +} + +func (x *IdentifiedClientState) Reset() { + *x = IdentifiedClientState{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_client_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *IdentifiedClientState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IdentifiedClientState) ProtoMessage() {} + +// Deprecated: Use IdentifiedClientState.ProtoReflect.Descriptor instead. +func (*IdentifiedClientState) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_client_proto_rawDescGZIP(), []int{0} +} + +func (x *IdentifiedClientState) GetChainName() string { + if x != nil { + return x.ChainName + } + return "" +} + +func (x *IdentifiedClientState) GetClientState() *anypb.Any { + if x != nil { + return x.ClientState + } + return nil +} + +// IdentifiedRelayer defines a list of authorized relayers for the specified +// client. +type IdentifiedRelayers struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // client identifier + ChainName string `protobuf:"bytes,1,opt,name=chain_name,json=chainName,proto3" json:"chain_name,omitempty"` + // authorized relayer list + Relayers []string `protobuf:"bytes,2,rep,name=relayers,proto3" json:"relayers,omitempty"` +} + +func (x *IdentifiedRelayers) Reset() { + *x = IdentifiedRelayers{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_client_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *IdentifiedRelayers) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IdentifiedRelayers) ProtoMessage() {} + +// Deprecated: Use IdentifiedRelayers.ProtoReflect.Descriptor instead. +func (*IdentifiedRelayers) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_client_proto_rawDescGZIP(), []int{1} +} + +func (x *IdentifiedRelayers) GetChainName() string { + if x != nil { + return x.ChainName + } + return "" +} + +func (x *IdentifiedRelayers) GetRelayers() []string { + if x != nil { + return x.Relayers + } + return nil +} + +// ConsensusStateWithHeight defines a consensus state with an additional height +// field. +type ConsensusStateWithHeight struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // consensus state height + Height *Height `protobuf:"bytes,1,opt,name=height,proto3" json:"height,omitempty"` + // consensus state + ConsensusState *anypb.Any `protobuf:"bytes,2,opt,name=consensus_state,json=consensusState,proto3" json:"consensus_state,omitempty"` +} + +func (x *ConsensusStateWithHeight) Reset() { + *x = ConsensusStateWithHeight{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_client_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ConsensusStateWithHeight) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ConsensusStateWithHeight) ProtoMessage() {} + +// Deprecated: Use ConsensusStateWithHeight.ProtoReflect.Descriptor instead. +func (*ConsensusStateWithHeight) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_client_proto_rawDescGZIP(), []int{2} +} + +func (x *ConsensusStateWithHeight) GetHeight() *Height { + if x != nil { + return x.Height + } + return nil +} + +func (x *ConsensusStateWithHeight) GetConsensusState() *anypb.Any { + if x != nil { + return x.ConsensusState + } + return nil +} + +// ClientConsensusStates defines all the stored consensus states for a given +// client. +type ClientConsensusStates struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // client identifier + ChainName string `protobuf:"bytes,1,opt,name=chain_name,json=chainName,proto3" json:"chain_name,omitempty"` + // consensus states and their heights associated with the client + ConsensusStates []*ConsensusStateWithHeight `protobuf:"bytes,2,rep,name=consensus_states,json=consensusStates,proto3" json:"consensus_states,omitempty"` +} + +func (x *ClientConsensusStates) Reset() { + *x = ClientConsensusStates{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_client_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ClientConsensusStates) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ClientConsensusStates) ProtoMessage() {} + +// Deprecated: Use ClientConsensusStates.ProtoReflect.Descriptor instead. +func (*ClientConsensusStates) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_client_proto_rawDescGZIP(), []int{3} +} + +func (x *ClientConsensusStates) GetChainName() string { + if x != nil { + return x.ChainName + } + return "" +} + +func (x *ClientConsensusStates) GetConsensusStates() []*ConsensusStateWithHeight { + if x != nil { + return x.ConsensusStates + } + return nil +} + +// CreateClientProposal defines a overnance proposal to create an TIBC client +type CreateClientProposal struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // the title of the update proposal + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` + // the description of the proposal + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` + // the client identifier for the client to be updated if the proposal passes + ChainName string `protobuf:"bytes,3,opt,name=chain_name,json=chainName,proto3" json:"chain_name,omitempty"` + // light client state + ClientState *anypb.Any `protobuf:"bytes,4,opt,name=client_state,json=clientState,proto3" json:"client_state,omitempty"` + // consensus state associated with the client that corresponds to a given + // height. + ConsensusState *anypb.Any `protobuf:"bytes,5,opt,name=consensus_state,json=consensusState,proto3" json:"consensus_state,omitempty"` +} + +func (x *CreateClientProposal) Reset() { + *x = CreateClientProposal{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_client_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CreateClientProposal) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateClientProposal) ProtoMessage() {} + +// Deprecated: Use CreateClientProposal.ProtoReflect.Descriptor instead. +func (*CreateClientProposal) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_client_proto_rawDescGZIP(), []int{4} +} + +func (x *CreateClientProposal) GetTitle() string { + if x != nil { + return x.Title + } + return "" +} + +func (x *CreateClientProposal) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +func (x *CreateClientProposal) GetChainName() string { + if x != nil { + return x.ChainName + } + return "" +} + +func (x *CreateClientProposal) GetClientState() *anypb.Any { + if x != nil { + return x.ClientState + } + return nil +} + +func (x *CreateClientProposal) GetConsensusState() *anypb.Any { + if x != nil { + return x.ConsensusState + } + return nil +} + +// UpgradeClientProposal defines a overnance proposal to overide an TIBC client +// state +type UpgradeClientProposal struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // the title of the update proposal + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` + // the description of the proposal + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` + // the client identifier for the client to be updated if the proposal passes + ChainName string `protobuf:"bytes,3,opt,name=chain_name,json=chainName,proto3" json:"chain_name,omitempty"` + // client state + ClientState *anypb.Any `protobuf:"bytes,4,opt,name=client_state,json=clientState,proto3" json:"client_state,omitempty"` + // consensus state + ConsensusState *anypb.Any `protobuf:"bytes,5,opt,name=consensus_state,json=consensusState,proto3" json:"consensus_state,omitempty"` +} + +func (x *UpgradeClientProposal) Reset() { + *x = UpgradeClientProposal{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_client_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UpgradeClientProposal) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpgradeClientProposal) ProtoMessage() {} + +// Deprecated: Use UpgradeClientProposal.ProtoReflect.Descriptor instead. +func (*UpgradeClientProposal) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_client_proto_rawDescGZIP(), []int{5} +} + +func (x *UpgradeClientProposal) GetTitle() string { + if x != nil { + return x.Title + } + return "" +} + +func (x *UpgradeClientProposal) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +func (x *UpgradeClientProposal) GetChainName() string { + if x != nil { + return x.ChainName + } + return "" +} + +func (x *UpgradeClientProposal) GetClientState() *anypb.Any { + if x != nil { + return x.ClientState + } + return nil +} + +func (x *UpgradeClientProposal) GetConsensusState() *anypb.Any { + if x != nil { + return x.ConsensusState + } + return nil +} + +// RegisterRelayerProposal defines a overnance proposal to register some +// relayers for updating a client state. +type RegisterRelayerProposal struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // the title of the update proposal + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` + // the description of the proposal + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` + // the client identifier for the client to be updated if the proposal passes + ChainName string `protobuf:"bytes,3,opt,name=chain_name,json=chainName,proto3" json:"chain_name,omitempty"` + // relayer address list + Relayers []string `protobuf:"bytes,4,rep,name=relayers,proto3" json:"relayers,omitempty"` +} + +func (x *RegisterRelayerProposal) Reset() { + *x = RegisterRelayerProposal{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_client_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RegisterRelayerProposal) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RegisterRelayerProposal) ProtoMessage() {} + +// Deprecated: Use RegisterRelayerProposal.ProtoReflect.Descriptor instead. +func (*RegisterRelayerProposal) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_client_proto_rawDescGZIP(), []int{6} +} + +func (x *RegisterRelayerProposal) GetTitle() string { + if x != nil { + return x.Title + } + return "" +} + +func (x *RegisterRelayerProposal) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +func (x *RegisterRelayerProposal) GetChainName() string { + if x != nil { + return x.ChainName + } + return "" +} + +func (x *RegisterRelayerProposal) GetRelayers() []string { + if x != nil { + return x.Relayers + } + return nil +} + +// Height is a monotonically increasing data type +// that can be compared against another Height for the purposes of updating and +// freezing clients +// +// Normally the RevisionHeight is incremented at each height while keeping +// RevisionNumber the same. However some consensus algorithms may choose to +// reset the height in certain conditions e.g. hard forks, state-machine +// breaking changes In these cases, the RevisionNumber is incremented so that +// height continues to be monitonically increasing even as the RevisionHeight +// gets reset +type Height struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // the revision that the client is currently on + RevisionNumber uint64 `protobuf:"varint,1,opt,name=revision_number,json=revisionNumber,proto3" json:"revision_number,omitempty"` + // the height within the given revision + RevisionHeight uint64 `protobuf:"varint,2,opt,name=revision_height,json=revisionHeight,proto3" json:"revision_height,omitempty"` +} + +func (x *Height) Reset() { + *x = Height{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_client_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Height) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Height) ProtoMessage() {} + +// Deprecated: Use Height.ProtoReflect.Descriptor instead. +func (*Height) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_client_proto_rawDescGZIP(), []int{7} +} + +func (x *Height) GetRevisionNumber() uint64 { + if x != nil { + return x.RevisionNumber + } + return 0 +} + +func (x *Height) GetRevisionHeight() uint64 { + if x != nil { + return x.RevisionHeight + } + return 0 +} + +var File_tibc_core_client_v1_client_proto protoreflect.FileDescriptor + +var file_tibc_core_client_v1_client_proto_rawDesc = []byte{ + 0x0a, 0x20, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x12, 0x13, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 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, 0x22, 0x6f, 0x0a, 0x15, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x65, 0x64, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, + 0x12, 0x37, 0x0a, 0x0c, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, + 0x18, 0x02, 0x20, 0x01, 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, 0x0b, 0x63, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x22, 0x4f, 0x0a, 0x12, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x64, 0x52, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x12, + 0x1d, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1a, + 0x0a, 0x08, 0x72, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, + 0x52, 0x08, 0x72, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x22, 0x94, 0x01, 0x0a, 0x18, 0x43, + 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x57, 0x69, 0x74, + 0x68, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x39, 0x0a, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, + 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x65, + 0x69, 0x67, 0x68, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x06, 0x68, 0x65, 0x69, 0x67, + 0x68, 0x74, 0x12, 0x3d, 0x0a, 0x0f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x5f, + 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 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, 0x0e, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x22, 0x96, 0x01, 0x0a, 0x15, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x73, + 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x63, + 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x09, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x5e, 0x0a, 0x10, 0x63, 0x6f, + 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x18, 0x02, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x73, 0x65, + 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x57, 0x69, 0x74, 0x68, 0x48, 0x65, 0x69, + 0x67, 0x68, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0f, 0x63, 0x6f, 0x6e, 0x73, 0x65, + 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x22, 0xeb, 0x01, 0x0a, 0x14, 0x43, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x6f, + 0x73, 0x61, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x63, + 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x09, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x37, 0x0a, 0x0c, 0x63, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 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, 0x0b, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, + 0x61, 0x74, 0x65, 0x12, 0x3d, 0x0a, 0x0f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, + 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 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, 0x0e, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, + 0x74, 0x65, 0x3a, 0x04, 0x88, 0xa0, 0x1f, 0x00, 0x22, 0xec, 0x01, 0x0a, 0x15, 0x55, 0x70, 0x67, + 0x72, 0x61, 0x64, 0x65, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, + 0x61, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, + 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x68, + 0x61, 0x69, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x37, 0x0a, 0x0c, 0x63, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 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, 0x0b, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, + 0x74, 0x65, 0x12, 0x3d, 0x0a, 0x0f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x5f, + 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 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, 0x0e, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x3a, 0x04, 0x88, 0xa0, 0x1f, 0x00, 0x22, 0x92, 0x01, 0x0a, 0x17, 0x52, 0x65, 0x67, 0x69, + 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x6f, + 0x73, 0x61, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x63, + 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x09, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, + 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x72, 0x65, + 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x3a, 0x04, 0x88, 0xa0, 0x1f, 0x00, 0x22, 0x9c, 0x01, 0x0a, + 0x06, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x43, 0x0a, 0x0f, 0x72, 0x65, 0x76, 0x69, 0x73, + 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, + 0x42, 0x1a, 0xf2, 0xde, 0x1f, 0x16, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x72, 0x65, 0x76, 0x69, + 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x52, 0x0e, 0x72, 0x65, + 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x43, 0x0a, 0x0f, + 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x04, 0x42, 0x1a, 0xf2, 0xde, 0x1f, 0x16, 0x79, 0x61, 0x6d, 0x6c, 0x3a, + 0x22, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, + 0x22, 0x52, 0x0e, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x69, 0x67, 0x68, + 0x74, 0x3a, 0x08, 0x88, 0xa0, 0x1f, 0x00, 0x98, 0xa0, 0x1f, 0x00, 0x42, 0xd4, 0x01, 0x0a, 0x17, + 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x42, 0x0b, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, + 0x63, 0x2d, 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, + 0x72, 0x65, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x3b, 0x63, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x54, 0x43, 0x43, 0xaa, 0x02, 0x13, 0x54, 0x69, + 0x62, 0x63, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x56, + 0x31, 0xca, 0x02, 0x13, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x43, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x1f, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x43, + 0x6f, 0x72, 0x65, 0x5c, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, + 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x16, 0x54, 0x69, 0x62, 0x63, + 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x3a, 0x3a, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x3a, 0x3a, + 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_core_client_v1_client_proto_rawDescOnce sync.Once + file_tibc_core_client_v1_client_proto_rawDescData = file_tibc_core_client_v1_client_proto_rawDesc +) + +func file_tibc_core_client_v1_client_proto_rawDescGZIP() []byte { + file_tibc_core_client_v1_client_proto_rawDescOnce.Do(func() { + file_tibc_core_client_v1_client_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_core_client_v1_client_proto_rawDescData) + }) + return file_tibc_core_client_v1_client_proto_rawDescData +} + +var file_tibc_core_client_v1_client_proto_msgTypes = make([]protoimpl.MessageInfo, 8) +var file_tibc_core_client_v1_client_proto_goTypes = []interface{}{ + (*IdentifiedClientState)(nil), // 0: tibc.core.client.v1.IdentifiedClientState + (*IdentifiedRelayers)(nil), // 1: tibc.core.client.v1.IdentifiedRelayers + (*ConsensusStateWithHeight)(nil), // 2: tibc.core.client.v1.ConsensusStateWithHeight + (*ClientConsensusStates)(nil), // 3: tibc.core.client.v1.ClientConsensusStates + (*CreateClientProposal)(nil), // 4: tibc.core.client.v1.CreateClientProposal + (*UpgradeClientProposal)(nil), // 5: tibc.core.client.v1.UpgradeClientProposal + (*RegisterRelayerProposal)(nil), // 6: tibc.core.client.v1.RegisterRelayerProposal + (*Height)(nil), // 7: tibc.core.client.v1.Height + (*anypb.Any)(nil), // 8: google.protobuf.Any +} +var file_tibc_core_client_v1_client_proto_depIdxs = []int32{ + 8, // 0: tibc.core.client.v1.IdentifiedClientState.client_state:type_name -> google.protobuf.Any + 7, // 1: tibc.core.client.v1.ConsensusStateWithHeight.height:type_name -> tibc.core.client.v1.Height + 8, // 2: tibc.core.client.v1.ConsensusStateWithHeight.consensus_state:type_name -> google.protobuf.Any + 2, // 3: tibc.core.client.v1.ClientConsensusStates.consensus_states:type_name -> tibc.core.client.v1.ConsensusStateWithHeight + 8, // 4: tibc.core.client.v1.CreateClientProposal.client_state:type_name -> google.protobuf.Any + 8, // 5: tibc.core.client.v1.CreateClientProposal.consensus_state:type_name -> google.protobuf.Any + 8, // 6: tibc.core.client.v1.UpgradeClientProposal.client_state:type_name -> google.protobuf.Any + 8, // 7: tibc.core.client.v1.UpgradeClientProposal.consensus_state: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_tibc_core_client_v1_client_proto_init() } +func file_tibc_core_client_v1_client_proto_init() { + if File_tibc_core_client_v1_client_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_tibc_core_client_v1_client_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*IdentifiedClientState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_client_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*IdentifiedRelayers); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_client_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ConsensusStateWithHeight); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_client_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ClientConsensusStates); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_client_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CreateClientProposal); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_client_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UpgradeClientProposal); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_client_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RegisterRelayerProposal); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_client_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Height); 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_tibc_core_client_v1_client_proto_rawDesc, + NumEnums: 0, + NumMessages: 8, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_tibc_core_client_v1_client_proto_goTypes, + DependencyIndexes: file_tibc_core_client_v1_client_proto_depIdxs, + MessageInfos: file_tibc_core_client_v1_client_proto_msgTypes, + }.Build() + File_tibc_core_client_v1_client_proto = out.File + file_tibc_core_client_v1_client_proto_rawDesc = nil + file_tibc_core_client_v1_client_proto_goTypes = nil + file_tibc_core_client_v1_client_proto_depIdxs = nil +} diff --git a/api/tibc/core/client/v1/genesis.pulsar.go b/api/tibc/core/client/v1/genesis.pulsar.go new file mode 100644 index 00000000..ad8aa9fa --- /dev/null +++ b/api/tibc/core/client/v1/genesis.pulsar.go @@ -0,0 +1,2376 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package clientv1 + +import ( + fmt "fmt" + 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" + io "io" + reflect "reflect" + sync "sync" +) + +var _ protoreflect.List = (*_GenesisState_1_list)(nil) + +type _GenesisState_1_list struct { + list *[]*IdentifiedClientState +} + +func (x *_GenesisState_1_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_GenesisState_1_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_GenesisState_1_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*IdentifiedClientState) + (*x.list)[i] = concreteValue +} + +func (x *_GenesisState_1_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*IdentifiedClientState) + *x.list = append(*x.list, concreteValue) +} + +func (x *_GenesisState_1_list) AppendMutable() protoreflect.Value { + v := new(IdentifiedClientState) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_GenesisState_1_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_GenesisState_1_list) NewElement() protoreflect.Value { + v := new(IdentifiedClientState) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_GenesisState_1_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_GenesisState_2_list)(nil) + +type _GenesisState_2_list struct { + list *[]*ClientConsensusStates +} + +func (x *_GenesisState_2_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_GenesisState_2_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_GenesisState_2_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*ClientConsensusStates) + (*x.list)[i] = concreteValue +} + +func (x *_GenesisState_2_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*ClientConsensusStates) + *x.list = append(*x.list, concreteValue) +} + +func (x *_GenesisState_2_list) AppendMutable() protoreflect.Value { + v := new(ClientConsensusStates) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_GenesisState_2_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_GenesisState_2_list) NewElement() protoreflect.Value { + v := new(ClientConsensusStates) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_GenesisState_2_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_GenesisState_3_list)(nil) + +type _GenesisState_3_list struct { + list *[]*IdentifiedGenesisMetadata +} + +func (x *_GenesisState_3_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_GenesisState_3_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_GenesisState_3_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*IdentifiedGenesisMetadata) + (*x.list)[i] = concreteValue +} + +func (x *_GenesisState_3_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*IdentifiedGenesisMetadata) + *x.list = append(*x.list, concreteValue) +} + +func (x *_GenesisState_3_list) AppendMutable() protoreflect.Value { + v := new(IdentifiedGenesisMetadata) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_GenesisState_3_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_GenesisState_3_list) NewElement() protoreflect.Value { + v := new(IdentifiedGenesisMetadata) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_GenesisState_3_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_GenesisState_6_list)(nil) + +type _GenesisState_6_list struct { + list *[]*IdentifiedRelayers +} + +func (x *_GenesisState_6_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_GenesisState_6_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_GenesisState_6_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*IdentifiedRelayers) + (*x.list)[i] = concreteValue +} + +func (x *_GenesisState_6_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*IdentifiedRelayers) + *x.list = append(*x.list, concreteValue) +} + +func (x *_GenesisState_6_list) AppendMutable() protoreflect.Value { + v := new(IdentifiedRelayers) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_GenesisState_6_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_GenesisState_6_list) NewElement() protoreflect.Value { + v := new(IdentifiedRelayers) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_GenesisState_6_list) IsValid() bool { + return x.list != nil +} + +var ( + md_GenesisState protoreflect.MessageDescriptor + fd_GenesisState_clients protoreflect.FieldDescriptor + fd_GenesisState_clients_consensus protoreflect.FieldDescriptor + fd_GenesisState_clients_metadata protoreflect.FieldDescriptor + fd_GenesisState_native_chain_name protoreflect.FieldDescriptor + fd_GenesisState_relayers protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_genesis_proto_init() + md_GenesisState = File_tibc_core_client_v1_genesis_proto.Messages().ByName("GenesisState") + fd_GenesisState_clients = md_GenesisState.Fields().ByName("clients") + fd_GenesisState_clients_consensus = md_GenesisState.Fields().ByName("clients_consensus") + fd_GenesisState_clients_metadata = md_GenesisState.Fields().ByName("clients_metadata") + fd_GenesisState_native_chain_name = md_GenesisState.Fields().ByName("native_chain_name") + fd_GenesisState_relayers = md_GenesisState.Fields().ByName("relayers") +} + +var _ protoreflect.Message = (*fastReflection_GenesisState)(nil) + +type fastReflection_GenesisState GenesisState + +func (x *GenesisState) ProtoReflect() protoreflect.Message { + return (*fastReflection_GenesisState)(x) +} + +func (x *GenesisState) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_genesis_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_GenesisState_messageType fastReflection_GenesisState_messageType +var _ protoreflect.MessageType = fastReflection_GenesisState_messageType{} + +type fastReflection_GenesisState_messageType struct{} + +func (x fastReflection_GenesisState_messageType) Zero() protoreflect.Message { + return (*fastReflection_GenesisState)(nil) +} +func (x fastReflection_GenesisState_messageType) New() protoreflect.Message { + return new(fastReflection_GenesisState) +} +func (x fastReflection_GenesisState_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_GenesisState +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_GenesisState) Descriptor() protoreflect.MessageDescriptor { + return md_GenesisState +} + +// 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_GenesisState) Type() protoreflect.MessageType { + return _fastReflection_GenesisState_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_GenesisState) New() protoreflect.Message { + return new(fastReflection_GenesisState) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_GenesisState) Interface() protoreflect.ProtoMessage { + return (*GenesisState)(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_GenesisState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.Clients) != 0 { + value := protoreflect.ValueOfList(&_GenesisState_1_list{list: &x.Clients}) + if !f(fd_GenesisState_clients, value) { + return + } + } + if len(x.ClientsConsensus) != 0 { + value := protoreflect.ValueOfList(&_GenesisState_2_list{list: &x.ClientsConsensus}) + if !f(fd_GenesisState_clients_consensus, value) { + return + } + } + if len(x.ClientsMetadata) != 0 { + value := protoreflect.ValueOfList(&_GenesisState_3_list{list: &x.ClientsMetadata}) + if !f(fd_GenesisState_clients_metadata, value) { + return + } + } + if x.NativeChainName != "" { + value := protoreflect.ValueOfString(x.NativeChainName) + if !f(fd_GenesisState_native_chain_name, value) { + return + } + } + if len(x.Relayers) != 0 { + value := protoreflect.ValueOfList(&_GenesisState_6_list{list: &x.Relayers}) + if !f(fd_GenesisState_relayers, 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_GenesisState) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.GenesisState.clients": + return len(x.Clients) != 0 + case "tibc.core.client.v1.GenesisState.clients_consensus": + return len(x.ClientsConsensus) != 0 + case "tibc.core.client.v1.GenesisState.clients_metadata": + return len(x.ClientsMetadata) != 0 + case "tibc.core.client.v1.GenesisState.native_chain_name": + return x.NativeChainName != "" + case "tibc.core.client.v1.GenesisState.relayers": + return len(x.Relayers) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.client.v1.GenesisState 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_GenesisState) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.GenesisState.clients": + x.Clients = nil + case "tibc.core.client.v1.GenesisState.clients_consensus": + x.ClientsConsensus = nil + case "tibc.core.client.v1.GenesisState.clients_metadata": + x.ClientsMetadata = nil + case "tibc.core.client.v1.GenesisState.native_chain_name": + x.NativeChainName = "" + case "tibc.core.client.v1.GenesisState.relayers": + x.Relayers = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.client.v1.GenesisState 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_GenesisState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.GenesisState.clients": + if len(x.Clients) == 0 { + return protoreflect.ValueOfList(&_GenesisState_1_list{}) + } + listValue := &_GenesisState_1_list{list: &x.Clients} + return protoreflect.ValueOfList(listValue) + case "tibc.core.client.v1.GenesisState.clients_consensus": + if len(x.ClientsConsensus) == 0 { + return protoreflect.ValueOfList(&_GenesisState_2_list{}) + } + listValue := &_GenesisState_2_list{list: &x.ClientsConsensus} + return protoreflect.ValueOfList(listValue) + case "tibc.core.client.v1.GenesisState.clients_metadata": + if len(x.ClientsMetadata) == 0 { + return protoreflect.ValueOfList(&_GenesisState_3_list{}) + } + listValue := &_GenesisState_3_list{list: &x.ClientsMetadata} + return protoreflect.ValueOfList(listValue) + case "tibc.core.client.v1.GenesisState.native_chain_name": + value := x.NativeChainName + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.GenesisState.relayers": + if len(x.Relayers) == 0 { + return protoreflect.ValueOfList(&_GenesisState_6_list{}) + } + listValue := &_GenesisState_6_list{list: &x.Relayers} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.client.v1.GenesisState 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_GenesisState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.GenesisState.clients": + lv := value.List() + clv := lv.(*_GenesisState_1_list) + x.Clients = *clv.list + case "tibc.core.client.v1.GenesisState.clients_consensus": + lv := value.List() + clv := lv.(*_GenesisState_2_list) + x.ClientsConsensus = *clv.list + case "tibc.core.client.v1.GenesisState.clients_metadata": + lv := value.List() + clv := lv.(*_GenesisState_3_list) + x.ClientsMetadata = *clv.list + case "tibc.core.client.v1.GenesisState.native_chain_name": + x.NativeChainName = value.Interface().(string) + case "tibc.core.client.v1.GenesisState.relayers": + lv := value.List() + clv := lv.(*_GenesisState_6_list) + x.Relayers = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.client.v1.GenesisState 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_GenesisState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.GenesisState.clients": + if x.Clients == nil { + x.Clients = []*IdentifiedClientState{} + } + value := &_GenesisState_1_list{list: &x.Clients} + return protoreflect.ValueOfList(value) + case "tibc.core.client.v1.GenesisState.clients_consensus": + if x.ClientsConsensus == nil { + x.ClientsConsensus = []*ClientConsensusStates{} + } + value := &_GenesisState_2_list{list: &x.ClientsConsensus} + return protoreflect.ValueOfList(value) + case "tibc.core.client.v1.GenesisState.clients_metadata": + if x.ClientsMetadata == nil { + x.ClientsMetadata = []*IdentifiedGenesisMetadata{} + } + value := &_GenesisState_3_list{list: &x.ClientsMetadata} + return protoreflect.ValueOfList(value) + case "tibc.core.client.v1.GenesisState.relayers": + if x.Relayers == nil { + x.Relayers = []*IdentifiedRelayers{} + } + value := &_GenesisState_6_list{list: &x.Relayers} + return protoreflect.ValueOfList(value) + case "tibc.core.client.v1.GenesisState.native_chain_name": + panic(fmt.Errorf("field native_chain_name of message tibc.core.client.v1.GenesisState is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.client.v1.GenesisState 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_GenesisState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.GenesisState.clients": + list := []*IdentifiedClientState{} + return protoreflect.ValueOfList(&_GenesisState_1_list{list: &list}) + case "tibc.core.client.v1.GenesisState.clients_consensus": + list := []*ClientConsensusStates{} + return protoreflect.ValueOfList(&_GenesisState_2_list{list: &list}) + case "tibc.core.client.v1.GenesisState.clients_metadata": + list := []*IdentifiedGenesisMetadata{} + return protoreflect.ValueOfList(&_GenesisState_3_list{list: &list}) + case "tibc.core.client.v1.GenesisState.native_chain_name": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.GenesisState.relayers": + list := []*IdentifiedRelayers{} + return protoreflect.ValueOfList(&_GenesisState_6_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.client.v1.GenesisState 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_GenesisState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.GenesisState", 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_GenesisState) 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_GenesisState) 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_GenesisState) 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_GenesisState) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*GenesisState) + 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.Clients) > 0 { + for _, e := range x.Clients { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if len(x.ClientsConsensus) > 0 { + for _, e := range x.ClientsConsensus { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if len(x.ClientsMetadata) > 0 { + for _, e := range x.ClientsMetadata { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + l = len(x.NativeChainName) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.Relayers) > 0 { + for _, e := range x.Relayers { + 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().(*GenesisState) + 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.Relayers) > 0 { + for iNdEx := len(x.Relayers) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.Relayers[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] = 0x32 + } + } + if len(x.NativeChainName) > 0 { + i -= len(x.NativeChainName) + copy(dAtA[i:], x.NativeChainName) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NativeChainName))) + i-- + dAtA[i] = 0x2a + } + if len(x.ClientsMetadata) > 0 { + for iNdEx := len(x.ClientsMetadata) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.ClientsMetadata[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.ClientsConsensus) > 0 { + for iNdEx := len(x.ClientsConsensus) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.ClientsConsensus[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] = 0x12 + } + } + if len(x.Clients) > 0 { + for iNdEx := len(x.Clients) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.Clients[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().(*GenesisState) + 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: GenesisState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GenesisState: 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 Clients", 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.Clients = append(x.Clients, &IdentifiedClientState{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Clients[len(x.Clients)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ClientsConsensus", 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.ClientsConsensus = append(x.ClientsConsensus, &ClientConsensusStates{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ClientsConsensus[len(x.ClientsConsensus)-1]); 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 ClientsMetadata", 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.ClientsMetadata = append(x.ClientsMetadata, &IdentifiedGenesisMetadata{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ClientsMetadata[len(x.ClientsMetadata)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NativeChainName", 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.NativeChainName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Relayers", 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.Relayers = append(x.Relayers, &IdentifiedRelayers{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Relayers[len(x.Relayers)-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_GenesisMetadata protoreflect.MessageDescriptor + fd_GenesisMetadata_key protoreflect.FieldDescriptor + fd_GenesisMetadata_value protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_genesis_proto_init() + md_GenesisMetadata = File_tibc_core_client_v1_genesis_proto.Messages().ByName("GenesisMetadata") + fd_GenesisMetadata_key = md_GenesisMetadata.Fields().ByName("key") + fd_GenesisMetadata_value = md_GenesisMetadata.Fields().ByName("value") +} + +var _ protoreflect.Message = (*fastReflection_GenesisMetadata)(nil) + +type fastReflection_GenesisMetadata GenesisMetadata + +func (x *GenesisMetadata) ProtoReflect() protoreflect.Message { + return (*fastReflection_GenesisMetadata)(x) +} + +func (x *GenesisMetadata) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_genesis_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_GenesisMetadata_messageType fastReflection_GenesisMetadata_messageType +var _ protoreflect.MessageType = fastReflection_GenesisMetadata_messageType{} + +type fastReflection_GenesisMetadata_messageType struct{} + +func (x fastReflection_GenesisMetadata_messageType) Zero() protoreflect.Message { + return (*fastReflection_GenesisMetadata)(nil) +} +func (x fastReflection_GenesisMetadata_messageType) New() protoreflect.Message { + return new(fastReflection_GenesisMetadata) +} +func (x fastReflection_GenesisMetadata_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_GenesisMetadata +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_GenesisMetadata) Descriptor() protoreflect.MessageDescriptor { + return md_GenesisMetadata +} + +// 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_GenesisMetadata) Type() protoreflect.MessageType { + return _fastReflection_GenesisMetadata_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_GenesisMetadata) New() protoreflect.Message { + return new(fastReflection_GenesisMetadata) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_GenesisMetadata) Interface() protoreflect.ProtoMessage { + return (*GenesisMetadata)(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_GenesisMetadata) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.Key) != 0 { + value := protoreflect.ValueOfBytes(x.Key) + if !f(fd_GenesisMetadata_key, value) { + return + } + } + if len(x.Value) != 0 { + value := protoreflect.ValueOfBytes(x.Value) + if !f(fd_GenesisMetadata_value, 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_GenesisMetadata) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.GenesisMetadata.key": + return len(x.Key) != 0 + case "tibc.core.client.v1.GenesisMetadata.value": + return len(x.Value) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.GenesisMetadata")) + } + panic(fmt.Errorf("message tibc.core.client.v1.GenesisMetadata 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_GenesisMetadata) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.GenesisMetadata.key": + x.Key = nil + case "tibc.core.client.v1.GenesisMetadata.value": + x.Value = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.GenesisMetadata")) + } + panic(fmt.Errorf("message tibc.core.client.v1.GenesisMetadata 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_GenesisMetadata) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.GenesisMetadata.key": + value := x.Key + return protoreflect.ValueOfBytes(value) + case "tibc.core.client.v1.GenesisMetadata.value": + value := x.Value + return protoreflect.ValueOfBytes(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.GenesisMetadata")) + } + panic(fmt.Errorf("message tibc.core.client.v1.GenesisMetadata 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_GenesisMetadata) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.GenesisMetadata.key": + x.Key = value.Bytes() + case "tibc.core.client.v1.GenesisMetadata.value": + x.Value = value.Bytes() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.GenesisMetadata")) + } + panic(fmt.Errorf("message tibc.core.client.v1.GenesisMetadata 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_GenesisMetadata) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.GenesisMetadata.key": + panic(fmt.Errorf("field key of message tibc.core.client.v1.GenesisMetadata is not mutable")) + case "tibc.core.client.v1.GenesisMetadata.value": + panic(fmt.Errorf("field value of message tibc.core.client.v1.GenesisMetadata is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.GenesisMetadata")) + } + panic(fmt.Errorf("message tibc.core.client.v1.GenesisMetadata 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_GenesisMetadata) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.GenesisMetadata.key": + return protoreflect.ValueOfBytes(nil) + case "tibc.core.client.v1.GenesisMetadata.value": + return protoreflect.ValueOfBytes(nil) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.GenesisMetadata")) + } + panic(fmt.Errorf("message tibc.core.client.v1.GenesisMetadata 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_GenesisMetadata) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.GenesisMetadata", 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_GenesisMetadata) 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_GenesisMetadata) 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_GenesisMetadata) 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_GenesisMetadata) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*GenesisMetadata) + 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.Key) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Value) + 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().(*GenesisMetadata) + 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.Value) > 0 { + i -= len(x.Value) + copy(dAtA[i:], x.Value) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Value))) + i-- + dAtA[i] = 0x12 + } + if len(x.Key) > 0 { + i -= len(x.Key) + copy(dAtA[i:], x.Key) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Key))) + 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().(*GenesisMetadata) + 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: GenesisMetadata: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GenesisMetadata: 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 Key", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Key = append(x.Key[:0], dAtA[iNdEx:postIndex]...) + if x.Key == nil { + x.Key = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Value = append(x.Value[:0], dAtA[iNdEx:postIndex]...) + if x.Value == nil { + x.Value = []byte{} + } + 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 = (*_IdentifiedGenesisMetadata_2_list)(nil) + +type _IdentifiedGenesisMetadata_2_list struct { + list *[]*GenesisMetadata +} + +func (x *_IdentifiedGenesisMetadata_2_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_IdentifiedGenesisMetadata_2_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_IdentifiedGenesisMetadata_2_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*GenesisMetadata) + (*x.list)[i] = concreteValue +} + +func (x *_IdentifiedGenesisMetadata_2_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*GenesisMetadata) + *x.list = append(*x.list, concreteValue) +} + +func (x *_IdentifiedGenesisMetadata_2_list) AppendMutable() protoreflect.Value { + v := new(GenesisMetadata) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_IdentifiedGenesisMetadata_2_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_IdentifiedGenesisMetadata_2_list) NewElement() protoreflect.Value { + v := new(GenesisMetadata) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_IdentifiedGenesisMetadata_2_list) IsValid() bool { + return x.list != nil +} + +var ( + md_IdentifiedGenesisMetadata protoreflect.MessageDescriptor + fd_IdentifiedGenesisMetadata_chain_name protoreflect.FieldDescriptor + fd_IdentifiedGenesisMetadata_metadata protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_genesis_proto_init() + md_IdentifiedGenesisMetadata = File_tibc_core_client_v1_genesis_proto.Messages().ByName("IdentifiedGenesisMetadata") + fd_IdentifiedGenesisMetadata_chain_name = md_IdentifiedGenesisMetadata.Fields().ByName("chain_name") + fd_IdentifiedGenesisMetadata_metadata = md_IdentifiedGenesisMetadata.Fields().ByName("metadata") +} + +var _ protoreflect.Message = (*fastReflection_IdentifiedGenesisMetadata)(nil) + +type fastReflection_IdentifiedGenesisMetadata IdentifiedGenesisMetadata + +func (x *IdentifiedGenesisMetadata) ProtoReflect() protoreflect.Message { + return (*fastReflection_IdentifiedGenesisMetadata)(x) +} + +func (x *IdentifiedGenesisMetadata) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_genesis_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_IdentifiedGenesisMetadata_messageType fastReflection_IdentifiedGenesisMetadata_messageType +var _ protoreflect.MessageType = fastReflection_IdentifiedGenesisMetadata_messageType{} + +type fastReflection_IdentifiedGenesisMetadata_messageType struct{} + +func (x fastReflection_IdentifiedGenesisMetadata_messageType) Zero() protoreflect.Message { + return (*fastReflection_IdentifiedGenesisMetadata)(nil) +} +func (x fastReflection_IdentifiedGenesisMetadata_messageType) New() protoreflect.Message { + return new(fastReflection_IdentifiedGenesisMetadata) +} +func (x fastReflection_IdentifiedGenesisMetadata_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_IdentifiedGenesisMetadata +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_IdentifiedGenesisMetadata) Descriptor() protoreflect.MessageDescriptor { + return md_IdentifiedGenesisMetadata +} + +// 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_IdentifiedGenesisMetadata) Type() protoreflect.MessageType { + return _fastReflection_IdentifiedGenesisMetadata_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_IdentifiedGenesisMetadata) New() protoreflect.Message { + return new(fastReflection_IdentifiedGenesisMetadata) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_IdentifiedGenesisMetadata) Interface() protoreflect.ProtoMessage { + return (*IdentifiedGenesisMetadata)(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_IdentifiedGenesisMetadata) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ChainName != "" { + value := protoreflect.ValueOfString(x.ChainName) + if !f(fd_IdentifiedGenesisMetadata_chain_name, value) { + return + } + } + if len(x.Metadata) != 0 { + value := protoreflect.ValueOfList(&_IdentifiedGenesisMetadata_2_list{list: &x.Metadata}) + if !f(fd_IdentifiedGenesisMetadata_metadata, 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_IdentifiedGenesisMetadata) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.IdentifiedGenesisMetadata.chain_name": + return x.ChainName != "" + case "tibc.core.client.v1.IdentifiedGenesisMetadata.metadata": + return len(x.Metadata) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.IdentifiedGenesisMetadata")) + } + panic(fmt.Errorf("message tibc.core.client.v1.IdentifiedGenesisMetadata 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_IdentifiedGenesisMetadata) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.IdentifiedGenesisMetadata.chain_name": + x.ChainName = "" + case "tibc.core.client.v1.IdentifiedGenesisMetadata.metadata": + x.Metadata = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.IdentifiedGenesisMetadata")) + } + panic(fmt.Errorf("message tibc.core.client.v1.IdentifiedGenesisMetadata 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_IdentifiedGenesisMetadata) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.IdentifiedGenesisMetadata.chain_name": + value := x.ChainName + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.IdentifiedGenesisMetadata.metadata": + if len(x.Metadata) == 0 { + return protoreflect.ValueOfList(&_IdentifiedGenesisMetadata_2_list{}) + } + listValue := &_IdentifiedGenesisMetadata_2_list{list: &x.Metadata} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.IdentifiedGenesisMetadata")) + } + panic(fmt.Errorf("message tibc.core.client.v1.IdentifiedGenesisMetadata 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_IdentifiedGenesisMetadata) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.IdentifiedGenesisMetadata.chain_name": + x.ChainName = value.Interface().(string) + case "tibc.core.client.v1.IdentifiedGenesisMetadata.metadata": + lv := value.List() + clv := lv.(*_IdentifiedGenesisMetadata_2_list) + x.Metadata = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.IdentifiedGenesisMetadata")) + } + panic(fmt.Errorf("message tibc.core.client.v1.IdentifiedGenesisMetadata 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_IdentifiedGenesisMetadata) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.IdentifiedGenesisMetadata.metadata": + if x.Metadata == nil { + x.Metadata = []*GenesisMetadata{} + } + value := &_IdentifiedGenesisMetadata_2_list{list: &x.Metadata} + return protoreflect.ValueOfList(value) + case "tibc.core.client.v1.IdentifiedGenesisMetadata.chain_name": + panic(fmt.Errorf("field chain_name of message tibc.core.client.v1.IdentifiedGenesisMetadata is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.IdentifiedGenesisMetadata")) + } + panic(fmt.Errorf("message tibc.core.client.v1.IdentifiedGenesisMetadata 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_IdentifiedGenesisMetadata) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.IdentifiedGenesisMetadata.chain_name": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.IdentifiedGenesisMetadata.metadata": + list := []*GenesisMetadata{} + return protoreflect.ValueOfList(&_IdentifiedGenesisMetadata_2_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.IdentifiedGenesisMetadata")) + } + panic(fmt.Errorf("message tibc.core.client.v1.IdentifiedGenesisMetadata 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_IdentifiedGenesisMetadata) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.IdentifiedGenesisMetadata", 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_IdentifiedGenesisMetadata) 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_IdentifiedGenesisMetadata) 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_IdentifiedGenesisMetadata) 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_IdentifiedGenesisMetadata) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*IdentifiedGenesisMetadata) + 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.ChainName) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.Metadata) > 0 { + for _, e := range x.Metadata { + 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().(*IdentifiedGenesisMetadata) + 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.Metadata) > 0 { + for iNdEx := len(x.Metadata) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.Metadata[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] = 0x12 + } + } + if len(x.ChainName) > 0 { + i -= len(x.ChainName) + copy(dAtA[i:], x.ChainName) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainName))) + 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().(*IdentifiedGenesisMetadata) + 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: IdentifiedGenesisMetadata: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: IdentifiedGenesisMetadata: 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 ChainName", 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.ChainName = 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 Metadata", 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.Metadata = append(x.Metadata, &GenesisMetadata{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Metadata[len(x.Metadata)-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: tibc/core/client/v1/genesis.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) +) + +// GenesisState defines the tibc client submodule's genesis state. +type GenesisState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // client states with their corresponding identifiers + Clients []*IdentifiedClientState `protobuf:"bytes,1,rep,name=clients,proto3" json:"clients,omitempty"` + // consensus states from each client + ClientsConsensus []*ClientConsensusStates `protobuf:"bytes,2,rep,name=clients_consensus,json=clientsConsensus,proto3" json:"clients_consensus,omitempty"` + // metadata from each client + ClientsMetadata []*IdentifiedGenesisMetadata `protobuf:"bytes,3,rep,name=clients_metadata,json=clientsMetadata,proto3" json:"clients_metadata,omitempty"` + // the chain name of the current chain + NativeChainName string `protobuf:"bytes,5,opt,name=native_chain_name,json=nativeChainName,proto3" json:"native_chain_name,omitempty"` + // IdentifiedRelayer defines a list of authorized relayers for the specified + // client. + Relayers []*IdentifiedRelayers `protobuf:"bytes,6,rep,name=relayers,proto3" json:"relayers,omitempty"` +} + +func (x *GenesisState) Reset() { + *x = GenesisState{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_genesis_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GenesisState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GenesisState) ProtoMessage() {} + +// Deprecated: Use GenesisState.ProtoReflect.Descriptor instead. +func (*GenesisState) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_genesis_proto_rawDescGZIP(), []int{0} +} + +func (x *GenesisState) GetClients() []*IdentifiedClientState { + if x != nil { + return x.Clients + } + return nil +} + +func (x *GenesisState) GetClientsConsensus() []*ClientConsensusStates { + if x != nil { + return x.ClientsConsensus + } + return nil +} + +func (x *GenesisState) GetClientsMetadata() []*IdentifiedGenesisMetadata { + if x != nil { + return x.ClientsMetadata + } + return nil +} + +func (x *GenesisState) GetNativeChainName() string { + if x != nil { + return x.NativeChainName + } + return "" +} + +func (x *GenesisState) GetRelayers() []*IdentifiedRelayers { + if x != nil { + return x.Relayers + } + return nil +} + +// GenesisMetadata defines the genesis type for metadata that clients may return +// with ExportMetadata +type GenesisMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // store key of metadata without chainName-prefix + Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + // metadata value + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` +} + +func (x *GenesisMetadata) Reset() { + *x = GenesisMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_genesis_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GenesisMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GenesisMetadata) ProtoMessage() {} + +// Deprecated: Use GenesisMetadata.ProtoReflect.Descriptor instead. +func (*GenesisMetadata) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_genesis_proto_rawDescGZIP(), []int{1} +} + +func (x *GenesisMetadata) GetKey() []byte { + if x != nil { + return x.Key + } + return nil +} + +func (x *GenesisMetadata) GetValue() []byte { + if x != nil { + return x.Value + } + return nil +} + +// IdentifiedGenesisMetadata has the client metadata with the corresponding +// chain name. +type IdentifiedGenesisMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ChainName string `protobuf:"bytes,1,opt,name=chain_name,json=chainName,proto3" json:"chain_name,omitempty"` + Metadata []*GenesisMetadata `protobuf:"bytes,2,rep,name=metadata,proto3" json:"metadata,omitempty"` +} + +func (x *IdentifiedGenesisMetadata) Reset() { + *x = IdentifiedGenesisMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_genesis_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *IdentifiedGenesisMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IdentifiedGenesisMetadata) ProtoMessage() {} + +// Deprecated: Use IdentifiedGenesisMetadata.ProtoReflect.Descriptor instead. +func (*IdentifiedGenesisMetadata) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_genesis_proto_rawDescGZIP(), []int{2} +} + +func (x *IdentifiedGenesisMetadata) GetChainName() string { + if x != nil { + return x.ChainName + } + return "" +} + +func (x *IdentifiedGenesisMetadata) GetMetadata() []*GenesisMetadata { + if x != nil { + return x.Metadata + } + return nil +} + +var File_tibc_core_client_v1_genesis_proto protoreflect.FileDescriptor + +var file_tibc_core_client_v1_genesis_proto_rawDesc = []byte{ + 0x0a, 0x21, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x13, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x1a, 0x20, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, + 0x6f, 0x72, 0x65, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 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, + 0x22, 0xc5, 0x03, 0x0a, 0x0c, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x12, 0x64, 0x0a, 0x07, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x42, 0x1e, + 0xc8, 0xde, 0x1f, 0x00, 0xaa, 0xdf, 0x1f, 0x16, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, 0x07, + 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x77, 0x0a, 0x11, 0x63, 0x6c, 0x69, 0x65, 0x6e, + 0x74, 0x73, 0x5f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x18, 0x02, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, + 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x42, 0x1e, + 0xc8, 0xde, 0x1f, 0x00, 0xaa, 0xdf, 0x1f, 0x16, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x43, + 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, 0x10, + 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x43, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, + 0x12, 0x5f, 0x0a, 0x10, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x5f, 0x6d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x74, 0x69, 0x62, + 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, + 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x64, 0x47, 0x65, 0x6e, 0x65, 0x73, + 0x69, 0x73, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, + 0x52, 0x0f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x12, 0x2a, 0x0a, 0x11, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, + 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x6e, 0x61, + 0x74, 0x69, 0x76, 0x65, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x49, 0x0a, + 0x08, 0x72, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x27, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x52, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x08, + 0x72, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x22, 0x3f, 0x0a, 0x0f, 0x47, 0x65, 0x6e, 0x65, + 0x73, 0x69, 0x73, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x10, 0x0a, 0x03, 0x6b, + 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x3a, 0x04, 0x88, 0xa0, 0x1f, 0x00, 0x22, 0x82, 0x01, 0x0a, 0x19, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x64, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x69, 0x6e, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x68, 0x61, + 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x46, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x47, + 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x42, 0x04, + 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x42, 0xd5, + 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x42, 0x0c, 0x47, 0x65, 0x6e, 0x65, + 0x73, 0x69, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3d, 0x67, 0x69, 0x74, 0x68, + 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, + 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2d, 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x74, 0x69, 0x62, + 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, + 0x3b, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x54, 0x43, 0x43, 0xaa, + 0x02, 0x13, 0x54, 0x69, 0x62, 0x63, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x13, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x43, 0x6f, 0x72, + 0x65, 0x5c, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x1f, 0x54, 0x69, + 0x62, 0x63, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5c, 0x56, + 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x16, + 0x54, 0x69, 0x62, 0x63, 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x3a, 0x3a, 0x43, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_core_client_v1_genesis_proto_rawDescOnce sync.Once + file_tibc_core_client_v1_genesis_proto_rawDescData = file_tibc_core_client_v1_genesis_proto_rawDesc +) + +func file_tibc_core_client_v1_genesis_proto_rawDescGZIP() []byte { + file_tibc_core_client_v1_genesis_proto_rawDescOnce.Do(func() { + file_tibc_core_client_v1_genesis_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_core_client_v1_genesis_proto_rawDescData) + }) + return file_tibc_core_client_v1_genesis_proto_rawDescData +} + +var file_tibc_core_client_v1_genesis_proto_msgTypes = make([]protoimpl.MessageInfo, 3) +var file_tibc_core_client_v1_genesis_proto_goTypes = []interface{}{ + (*GenesisState)(nil), // 0: tibc.core.client.v1.GenesisState + (*GenesisMetadata)(nil), // 1: tibc.core.client.v1.GenesisMetadata + (*IdentifiedGenesisMetadata)(nil), // 2: tibc.core.client.v1.IdentifiedGenesisMetadata + (*IdentifiedClientState)(nil), // 3: tibc.core.client.v1.IdentifiedClientState + (*ClientConsensusStates)(nil), // 4: tibc.core.client.v1.ClientConsensusStates + (*IdentifiedRelayers)(nil), // 5: tibc.core.client.v1.IdentifiedRelayers +} +var file_tibc_core_client_v1_genesis_proto_depIdxs = []int32{ + 3, // 0: tibc.core.client.v1.GenesisState.clients:type_name -> tibc.core.client.v1.IdentifiedClientState + 4, // 1: tibc.core.client.v1.GenesisState.clients_consensus:type_name -> tibc.core.client.v1.ClientConsensusStates + 2, // 2: tibc.core.client.v1.GenesisState.clients_metadata:type_name -> tibc.core.client.v1.IdentifiedGenesisMetadata + 5, // 3: tibc.core.client.v1.GenesisState.relayers:type_name -> tibc.core.client.v1.IdentifiedRelayers + 1, // 4: tibc.core.client.v1.IdentifiedGenesisMetadata.metadata:type_name -> tibc.core.client.v1.GenesisMetadata + 5, // [5:5] is the sub-list for method output_type + 5, // [5:5] is the sub-list for method input_type + 5, // [5:5] is the sub-list for extension type_name + 5, // [5:5] is the sub-list for extension extendee + 0, // [0:5] is the sub-list for field type_name +} + +func init() { file_tibc_core_client_v1_genesis_proto_init() } +func file_tibc_core_client_v1_genesis_proto_init() { + if File_tibc_core_client_v1_genesis_proto != nil { + return + } + file_tibc_core_client_v1_client_proto_init() + if !protoimpl.UnsafeEnabled { + file_tibc_core_client_v1_genesis_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GenesisState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_genesis_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GenesisMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_genesis_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*IdentifiedGenesisMetadata); 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_tibc_core_client_v1_genesis_proto_rawDesc, + NumEnums: 0, + NumMessages: 3, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_tibc_core_client_v1_genesis_proto_goTypes, + DependencyIndexes: file_tibc_core_client_v1_genesis_proto_depIdxs, + MessageInfos: file_tibc_core_client_v1_genesis_proto_msgTypes, + }.Build() + File_tibc_core_client_v1_genesis_proto = out.File + file_tibc_core_client_v1_genesis_proto_rawDesc = nil + file_tibc_core_client_v1_genesis_proto_goTypes = nil + file_tibc_core_client_v1_genesis_proto_depIdxs = nil +} diff --git a/api/tibc/core/client/v1/query.pulsar.go b/api/tibc/core/client/v1/query.pulsar.go new file mode 100644 index 00000000..4f4a62b0 --- /dev/null +++ b/api/tibc/core/client/v1/query.pulsar.go @@ -0,0 +1,6015 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package clientv1 + +import ( + v1beta1 "cosmossdk.io/api/cosmos/base/query/v1beta1" + fmt "fmt" + runtime "github.com/cosmos/cosmos-proto/runtime" + _ "github.com/cosmos/gogoproto/gogoproto" + _ "google.golang.org/genproto/googleapis/api/annotations" + 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" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_QueryClientStateRequest protoreflect.MessageDescriptor + fd_QueryClientStateRequest_chain_name protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_query_proto_init() + md_QueryClientStateRequest = File_tibc_core_client_v1_query_proto.Messages().ByName("QueryClientStateRequest") + fd_QueryClientStateRequest_chain_name = md_QueryClientStateRequest.Fields().ByName("chain_name") +} + +var _ protoreflect.Message = (*fastReflection_QueryClientStateRequest)(nil) + +type fastReflection_QueryClientStateRequest QueryClientStateRequest + +func (x *QueryClientStateRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryClientStateRequest)(x) +} + +func (x *QueryClientStateRequest) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_query_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryClientStateRequest_messageType fastReflection_QueryClientStateRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryClientStateRequest_messageType{} + +type fastReflection_QueryClientStateRequest_messageType struct{} + +func (x fastReflection_QueryClientStateRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryClientStateRequest)(nil) +} +func (x fastReflection_QueryClientStateRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryClientStateRequest) +} +func (x fastReflection_QueryClientStateRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClientStateRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryClientStateRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClientStateRequest +} + +// 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_QueryClientStateRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryClientStateRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryClientStateRequest) New() protoreflect.Message { + return new(fastReflection_QueryClientStateRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryClientStateRequest) Interface() protoreflect.ProtoMessage { + return (*QueryClientStateRequest)(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_QueryClientStateRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ChainName != "" { + value := protoreflect.ValueOfString(x.ChainName) + if !f(fd_QueryClientStateRequest_chain_name, 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_QueryClientStateRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.QueryClientStateRequest.chain_name": + return x.ChainName != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStateRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStateRequest 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_QueryClientStateRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.QueryClientStateRequest.chain_name": + x.ChainName = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStateRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStateRequest 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_QueryClientStateRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.QueryClientStateRequest.chain_name": + value := x.ChainName + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStateRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStateRequest 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_QueryClientStateRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.QueryClientStateRequest.chain_name": + x.ChainName = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStateRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStateRequest 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_QueryClientStateRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.QueryClientStateRequest.chain_name": + panic(fmt.Errorf("field chain_name of message tibc.core.client.v1.QueryClientStateRequest is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStateRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStateRequest 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_QueryClientStateRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.QueryClientStateRequest.chain_name": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStateRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStateRequest 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_QueryClientStateRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.QueryClientStateRequest", 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_QueryClientStateRequest) 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_QueryClientStateRequest) 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_QueryClientStateRequest) 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_QueryClientStateRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryClientStateRequest) + 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.ChainName) + 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().(*QueryClientStateRequest) + 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.ChainName) > 0 { + i -= len(x.ChainName) + copy(dAtA[i:], x.ChainName) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainName))) + 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().(*QueryClientStateRequest) + 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: QueryClientStateRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryClientStateRequest: 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 ChainName", 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.ChainName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_QueryClientStateResponse protoreflect.MessageDescriptor + fd_QueryClientStateResponse_client_state protoreflect.FieldDescriptor + fd_QueryClientStateResponse_proof protoreflect.FieldDescriptor + fd_QueryClientStateResponse_proof_height protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_query_proto_init() + md_QueryClientStateResponse = File_tibc_core_client_v1_query_proto.Messages().ByName("QueryClientStateResponse") + fd_QueryClientStateResponse_client_state = md_QueryClientStateResponse.Fields().ByName("client_state") + fd_QueryClientStateResponse_proof = md_QueryClientStateResponse.Fields().ByName("proof") + fd_QueryClientStateResponse_proof_height = md_QueryClientStateResponse.Fields().ByName("proof_height") +} + +var _ protoreflect.Message = (*fastReflection_QueryClientStateResponse)(nil) + +type fastReflection_QueryClientStateResponse QueryClientStateResponse + +func (x *QueryClientStateResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryClientStateResponse)(x) +} + +func (x *QueryClientStateResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_query_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryClientStateResponse_messageType fastReflection_QueryClientStateResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryClientStateResponse_messageType{} + +type fastReflection_QueryClientStateResponse_messageType struct{} + +func (x fastReflection_QueryClientStateResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryClientStateResponse)(nil) +} +func (x fastReflection_QueryClientStateResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryClientStateResponse) +} +func (x fastReflection_QueryClientStateResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClientStateResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryClientStateResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClientStateResponse +} + +// 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_QueryClientStateResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryClientStateResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryClientStateResponse) New() protoreflect.Message { + return new(fastReflection_QueryClientStateResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryClientStateResponse) Interface() protoreflect.ProtoMessage { + return (*QueryClientStateResponse)(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_QueryClientStateResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ClientState != nil { + value := protoreflect.ValueOfMessage(x.ClientState.ProtoReflect()) + if !f(fd_QueryClientStateResponse_client_state, value) { + return + } + } + if len(x.Proof) != 0 { + value := protoreflect.ValueOfBytes(x.Proof) + if !f(fd_QueryClientStateResponse_proof, value) { + return + } + } + if x.ProofHeight != nil { + value := protoreflect.ValueOfMessage(x.ProofHeight.ProtoReflect()) + if !f(fd_QueryClientStateResponse_proof_height, 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_QueryClientStateResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.QueryClientStateResponse.client_state": + return x.ClientState != nil + case "tibc.core.client.v1.QueryClientStateResponse.proof": + return len(x.Proof) != 0 + case "tibc.core.client.v1.QueryClientStateResponse.proof_height": + return x.ProofHeight != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStateResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStateResponse 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_QueryClientStateResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.QueryClientStateResponse.client_state": + x.ClientState = nil + case "tibc.core.client.v1.QueryClientStateResponse.proof": + x.Proof = nil + case "tibc.core.client.v1.QueryClientStateResponse.proof_height": + x.ProofHeight = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStateResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStateResponse 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_QueryClientStateResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.QueryClientStateResponse.client_state": + value := x.ClientState + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.client.v1.QueryClientStateResponse.proof": + value := x.Proof + return protoreflect.ValueOfBytes(value) + case "tibc.core.client.v1.QueryClientStateResponse.proof_height": + value := x.ProofHeight + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStateResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStateResponse 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_QueryClientStateResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.QueryClientStateResponse.client_state": + x.ClientState = value.Message().Interface().(*anypb.Any) + case "tibc.core.client.v1.QueryClientStateResponse.proof": + x.Proof = value.Bytes() + case "tibc.core.client.v1.QueryClientStateResponse.proof_height": + x.ProofHeight = value.Message().Interface().(*Height) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStateResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStateResponse 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_QueryClientStateResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.QueryClientStateResponse.client_state": + if x.ClientState == nil { + x.ClientState = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.ClientState.ProtoReflect()) + case "tibc.core.client.v1.QueryClientStateResponse.proof_height": + if x.ProofHeight == nil { + x.ProofHeight = new(Height) + } + return protoreflect.ValueOfMessage(x.ProofHeight.ProtoReflect()) + case "tibc.core.client.v1.QueryClientStateResponse.proof": + panic(fmt.Errorf("field proof of message tibc.core.client.v1.QueryClientStateResponse is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStateResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStateResponse 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_QueryClientStateResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.QueryClientStateResponse.client_state": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.client.v1.QueryClientStateResponse.proof": + return protoreflect.ValueOfBytes(nil) + case "tibc.core.client.v1.QueryClientStateResponse.proof_height": + m := new(Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStateResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStateResponse 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_QueryClientStateResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.QueryClientStateResponse", 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_QueryClientStateResponse) 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_QueryClientStateResponse) 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_QueryClientStateResponse) 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_QueryClientStateResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryClientStateResponse) + 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.ClientState != nil { + l = options.Size(x.ClientState) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Proof) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ProofHeight != nil { + l = options.Size(x.ProofHeight) + 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().(*QueryClientStateResponse) + 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.ProofHeight != nil { + encoded, err := options.Marshal(x.ProofHeight) + 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.Proof) > 0 { + i -= len(x.Proof) + copy(dAtA[i:], x.Proof) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Proof))) + i-- + dAtA[i] = 0x12 + } + if x.ClientState != nil { + encoded, err := options.Marshal(x.ClientState) + 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().(*QueryClientStateResponse) + 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: QueryClientStateResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryClientStateResponse: 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 ClientState", 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.ClientState == nil { + x.ClientState = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ClientState); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Proof = append(x.Proof[:0], dAtA[iNdEx:postIndex]...) + if x.Proof == nil { + x.Proof = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", 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.ProofHeight == nil { + x.ProofHeight = &Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ProofHeight); 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_QueryClientStatesRequest protoreflect.MessageDescriptor + fd_QueryClientStatesRequest_pagination protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_query_proto_init() + md_QueryClientStatesRequest = File_tibc_core_client_v1_query_proto.Messages().ByName("QueryClientStatesRequest") + fd_QueryClientStatesRequest_pagination = md_QueryClientStatesRequest.Fields().ByName("pagination") +} + +var _ protoreflect.Message = (*fastReflection_QueryClientStatesRequest)(nil) + +type fastReflection_QueryClientStatesRequest QueryClientStatesRequest + +func (x *QueryClientStatesRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryClientStatesRequest)(x) +} + +func (x *QueryClientStatesRequest) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_query_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_QueryClientStatesRequest_messageType fastReflection_QueryClientStatesRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryClientStatesRequest_messageType{} + +type fastReflection_QueryClientStatesRequest_messageType struct{} + +func (x fastReflection_QueryClientStatesRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryClientStatesRequest)(nil) +} +func (x fastReflection_QueryClientStatesRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryClientStatesRequest) +} +func (x fastReflection_QueryClientStatesRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClientStatesRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryClientStatesRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClientStatesRequest +} + +// 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_QueryClientStatesRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryClientStatesRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryClientStatesRequest) New() protoreflect.Message { + return new(fastReflection_QueryClientStatesRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryClientStatesRequest) Interface() protoreflect.ProtoMessage { + return (*QueryClientStatesRequest)(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_QueryClientStatesRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Pagination != nil { + value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + if !f(fd_QueryClientStatesRequest_pagination, 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_QueryClientStatesRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.QueryClientStatesRequest.pagination": + return x.Pagination != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStatesRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStatesRequest 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_QueryClientStatesRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.QueryClientStatesRequest.pagination": + x.Pagination = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStatesRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStatesRequest 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_QueryClientStatesRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.QueryClientStatesRequest.pagination": + value := x.Pagination + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStatesRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStatesRequest 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_QueryClientStatesRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.QueryClientStatesRequest.pagination": + x.Pagination = value.Message().Interface().(*v1beta1.PageRequest) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStatesRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStatesRequest 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_QueryClientStatesRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.QueryClientStatesRequest.pagination": + if x.Pagination == nil { + x.Pagination = new(v1beta1.PageRequest) + } + return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStatesRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStatesRequest 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_QueryClientStatesRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.QueryClientStatesRequest.pagination": + m := new(v1beta1.PageRequest) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStatesRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStatesRequest 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_QueryClientStatesRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.QueryClientStatesRequest", 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_QueryClientStatesRequest) 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_QueryClientStatesRequest) 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_QueryClientStatesRequest) 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_QueryClientStatesRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryClientStatesRequest) + 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.Pagination != nil { + l = options.Size(x.Pagination) + 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().(*QueryClientStatesRequest) + 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.Pagination != nil { + encoded, err := options.Marshal(x.Pagination) + 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().(*QueryClientStatesRequest) + 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: QueryClientStatesRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryClientStatesRequest: 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 Pagination", 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.Pagination == nil { + x.Pagination = &v1beta1.PageRequest{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); 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 = (*_QueryClientStatesResponse_1_list)(nil) + +type _QueryClientStatesResponse_1_list struct { + list *[]*IdentifiedClientState +} + +func (x *_QueryClientStatesResponse_1_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_QueryClientStatesResponse_1_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_QueryClientStatesResponse_1_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*IdentifiedClientState) + (*x.list)[i] = concreteValue +} + +func (x *_QueryClientStatesResponse_1_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*IdentifiedClientState) + *x.list = append(*x.list, concreteValue) +} + +func (x *_QueryClientStatesResponse_1_list) AppendMutable() protoreflect.Value { + v := new(IdentifiedClientState) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_QueryClientStatesResponse_1_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_QueryClientStatesResponse_1_list) NewElement() protoreflect.Value { + v := new(IdentifiedClientState) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_QueryClientStatesResponse_1_list) IsValid() bool { + return x.list != nil +} + +var ( + md_QueryClientStatesResponse protoreflect.MessageDescriptor + fd_QueryClientStatesResponse_client_states protoreflect.FieldDescriptor + fd_QueryClientStatesResponse_pagination protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_query_proto_init() + md_QueryClientStatesResponse = File_tibc_core_client_v1_query_proto.Messages().ByName("QueryClientStatesResponse") + fd_QueryClientStatesResponse_client_states = md_QueryClientStatesResponse.Fields().ByName("client_states") + fd_QueryClientStatesResponse_pagination = md_QueryClientStatesResponse.Fields().ByName("pagination") +} + +var _ protoreflect.Message = (*fastReflection_QueryClientStatesResponse)(nil) + +type fastReflection_QueryClientStatesResponse QueryClientStatesResponse + +func (x *QueryClientStatesResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryClientStatesResponse)(x) +} + +func (x *QueryClientStatesResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_query_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryClientStatesResponse_messageType fastReflection_QueryClientStatesResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryClientStatesResponse_messageType{} + +type fastReflection_QueryClientStatesResponse_messageType struct{} + +func (x fastReflection_QueryClientStatesResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryClientStatesResponse)(nil) +} +func (x fastReflection_QueryClientStatesResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryClientStatesResponse) +} +func (x fastReflection_QueryClientStatesResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClientStatesResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryClientStatesResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClientStatesResponse +} + +// 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_QueryClientStatesResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryClientStatesResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryClientStatesResponse) New() protoreflect.Message { + return new(fastReflection_QueryClientStatesResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryClientStatesResponse) Interface() protoreflect.ProtoMessage { + return (*QueryClientStatesResponse)(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_QueryClientStatesResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.ClientStates) != 0 { + value := protoreflect.ValueOfList(&_QueryClientStatesResponse_1_list{list: &x.ClientStates}) + if !f(fd_QueryClientStatesResponse_client_states, value) { + return + } + } + if x.Pagination != nil { + value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + if !f(fd_QueryClientStatesResponse_pagination, 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_QueryClientStatesResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.QueryClientStatesResponse.client_states": + return len(x.ClientStates) != 0 + case "tibc.core.client.v1.QueryClientStatesResponse.pagination": + return x.Pagination != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStatesResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStatesResponse 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_QueryClientStatesResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.QueryClientStatesResponse.client_states": + x.ClientStates = nil + case "tibc.core.client.v1.QueryClientStatesResponse.pagination": + x.Pagination = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStatesResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStatesResponse 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_QueryClientStatesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.QueryClientStatesResponse.client_states": + if len(x.ClientStates) == 0 { + return protoreflect.ValueOfList(&_QueryClientStatesResponse_1_list{}) + } + listValue := &_QueryClientStatesResponse_1_list{list: &x.ClientStates} + return protoreflect.ValueOfList(listValue) + case "tibc.core.client.v1.QueryClientStatesResponse.pagination": + value := x.Pagination + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStatesResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStatesResponse 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_QueryClientStatesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.QueryClientStatesResponse.client_states": + lv := value.List() + clv := lv.(*_QueryClientStatesResponse_1_list) + x.ClientStates = *clv.list + case "tibc.core.client.v1.QueryClientStatesResponse.pagination": + x.Pagination = value.Message().Interface().(*v1beta1.PageResponse) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStatesResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStatesResponse 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_QueryClientStatesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.QueryClientStatesResponse.client_states": + if x.ClientStates == nil { + x.ClientStates = []*IdentifiedClientState{} + } + value := &_QueryClientStatesResponse_1_list{list: &x.ClientStates} + return protoreflect.ValueOfList(value) + case "tibc.core.client.v1.QueryClientStatesResponse.pagination": + if x.Pagination == nil { + x.Pagination = new(v1beta1.PageResponse) + } + return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStatesResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStatesResponse 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_QueryClientStatesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.QueryClientStatesResponse.client_states": + list := []*IdentifiedClientState{} + return protoreflect.ValueOfList(&_QueryClientStatesResponse_1_list{list: &list}) + case "tibc.core.client.v1.QueryClientStatesResponse.pagination": + m := new(v1beta1.PageResponse) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryClientStatesResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryClientStatesResponse 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_QueryClientStatesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.QueryClientStatesResponse", 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_QueryClientStatesResponse) 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_QueryClientStatesResponse) 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_QueryClientStatesResponse) 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_QueryClientStatesResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryClientStatesResponse) + 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.ClientStates) > 0 { + for _, e := range x.ClientStates { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.Pagination != nil { + l = options.Size(x.Pagination) + 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().(*QueryClientStatesResponse) + 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.Pagination != nil { + encoded, err := options.Marshal(x.Pagination) + 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.ClientStates) > 0 { + for iNdEx := len(x.ClientStates) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.ClientStates[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().(*QueryClientStatesResponse) + 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: QueryClientStatesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryClientStatesResponse: 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 ClientStates", 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.ClientStates = append(x.ClientStates, &IdentifiedClientState{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ClientStates[len(x.ClientStates)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", 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.Pagination == nil { + x.Pagination = &v1beta1.PageResponse{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); 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_QueryConsensusStateRequest protoreflect.MessageDescriptor + fd_QueryConsensusStateRequest_chain_name protoreflect.FieldDescriptor + fd_QueryConsensusStateRequest_revision_number protoreflect.FieldDescriptor + fd_QueryConsensusStateRequest_revision_height protoreflect.FieldDescriptor + fd_QueryConsensusStateRequest_latest_height protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_query_proto_init() + md_QueryConsensusStateRequest = File_tibc_core_client_v1_query_proto.Messages().ByName("QueryConsensusStateRequest") + fd_QueryConsensusStateRequest_chain_name = md_QueryConsensusStateRequest.Fields().ByName("chain_name") + fd_QueryConsensusStateRequest_revision_number = md_QueryConsensusStateRequest.Fields().ByName("revision_number") + fd_QueryConsensusStateRequest_revision_height = md_QueryConsensusStateRequest.Fields().ByName("revision_height") + fd_QueryConsensusStateRequest_latest_height = md_QueryConsensusStateRequest.Fields().ByName("latest_height") +} + +var _ protoreflect.Message = (*fastReflection_QueryConsensusStateRequest)(nil) + +type fastReflection_QueryConsensusStateRequest QueryConsensusStateRequest + +func (x *QueryConsensusStateRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryConsensusStateRequest)(x) +} + +func (x *QueryConsensusStateRequest) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_query_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_QueryConsensusStateRequest_messageType fastReflection_QueryConsensusStateRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryConsensusStateRequest_messageType{} + +type fastReflection_QueryConsensusStateRequest_messageType struct{} + +func (x fastReflection_QueryConsensusStateRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryConsensusStateRequest)(nil) +} +func (x fastReflection_QueryConsensusStateRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryConsensusStateRequest) +} +func (x fastReflection_QueryConsensusStateRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryConsensusStateRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryConsensusStateRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryConsensusStateRequest +} + +// 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_QueryConsensusStateRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryConsensusStateRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryConsensusStateRequest) New() protoreflect.Message { + return new(fastReflection_QueryConsensusStateRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryConsensusStateRequest) Interface() protoreflect.ProtoMessage { + return (*QueryConsensusStateRequest)(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_QueryConsensusStateRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ChainName != "" { + value := protoreflect.ValueOfString(x.ChainName) + if !f(fd_QueryConsensusStateRequest_chain_name, value) { + return + } + } + if x.RevisionNumber != uint64(0) { + value := protoreflect.ValueOfUint64(x.RevisionNumber) + if !f(fd_QueryConsensusStateRequest_revision_number, value) { + return + } + } + if x.RevisionHeight != uint64(0) { + value := protoreflect.ValueOfUint64(x.RevisionHeight) + if !f(fd_QueryConsensusStateRequest_revision_height, value) { + return + } + } + if x.LatestHeight != false { + value := protoreflect.ValueOfBool(x.LatestHeight) + if !f(fd_QueryConsensusStateRequest_latest_height, 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_QueryConsensusStateRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.QueryConsensusStateRequest.chain_name": + return x.ChainName != "" + case "tibc.core.client.v1.QueryConsensusStateRequest.revision_number": + return x.RevisionNumber != uint64(0) + case "tibc.core.client.v1.QueryConsensusStateRequest.revision_height": + return x.RevisionHeight != uint64(0) + case "tibc.core.client.v1.QueryConsensusStateRequest.latest_height": + return x.LatestHeight != false + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStateRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStateRequest 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_QueryConsensusStateRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.QueryConsensusStateRequest.chain_name": + x.ChainName = "" + case "tibc.core.client.v1.QueryConsensusStateRequest.revision_number": + x.RevisionNumber = uint64(0) + case "tibc.core.client.v1.QueryConsensusStateRequest.revision_height": + x.RevisionHeight = uint64(0) + case "tibc.core.client.v1.QueryConsensusStateRequest.latest_height": + x.LatestHeight = false + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStateRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStateRequest 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_QueryConsensusStateRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.QueryConsensusStateRequest.chain_name": + value := x.ChainName + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.QueryConsensusStateRequest.revision_number": + value := x.RevisionNumber + return protoreflect.ValueOfUint64(value) + case "tibc.core.client.v1.QueryConsensusStateRequest.revision_height": + value := x.RevisionHeight + return protoreflect.ValueOfUint64(value) + case "tibc.core.client.v1.QueryConsensusStateRequest.latest_height": + value := x.LatestHeight + return protoreflect.ValueOfBool(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStateRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStateRequest 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_QueryConsensusStateRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.QueryConsensusStateRequest.chain_name": + x.ChainName = value.Interface().(string) + case "tibc.core.client.v1.QueryConsensusStateRequest.revision_number": + x.RevisionNumber = value.Uint() + case "tibc.core.client.v1.QueryConsensusStateRequest.revision_height": + x.RevisionHeight = value.Uint() + case "tibc.core.client.v1.QueryConsensusStateRequest.latest_height": + x.LatestHeight = value.Bool() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStateRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStateRequest 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_QueryConsensusStateRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.QueryConsensusStateRequest.chain_name": + panic(fmt.Errorf("field chain_name of message tibc.core.client.v1.QueryConsensusStateRequest is not mutable")) + case "tibc.core.client.v1.QueryConsensusStateRequest.revision_number": + panic(fmt.Errorf("field revision_number of message tibc.core.client.v1.QueryConsensusStateRequest is not mutable")) + case "tibc.core.client.v1.QueryConsensusStateRequest.revision_height": + panic(fmt.Errorf("field revision_height of message tibc.core.client.v1.QueryConsensusStateRequest is not mutable")) + case "tibc.core.client.v1.QueryConsensusStateRequest.latest_height": + panic(fmt.Errorf("field latest_height of message tibc.core.client.v1.QueryConsensusStateRequest is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStateRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStateRequest 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_QueryConsensusStateRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.QueryConsensusStateRequest.chain_name": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.QueryConsensusStateRequest.revision_number": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.core.client.v1.QueryConsensusStateRequest.revision_height": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.core.client.v1.QueryConsensusStateRequest.latest_height": + return protoreflect.ValueOfBool(false) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStateRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStateRequest 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_QueryConsensusStateRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.QueryConsensusStateRequest", 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_QueryConsensusStateRequest) 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_QueryConsensusStateRequest) 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_QueryConsensusStateRequest) 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_QueryConsensusStateRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryConsensusStateRequest) + 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.ChainName) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.RevisionNumber != 0 { + n += 1 + runtime.Sov(uint64(x.RevisionNumber)) + } + if x.RevisionHeight != 0 { + n += 1 + runtime.Sov(uint64(x.RevisionHeight)) + } + if x.LatestHeight { + n += 2 + } + 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().(*QueryConsensusStateRequest) + 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.LatestHeight { + i-- + if x.LatestHeight { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if x.RevisionHeight != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.RevisionHeight)) + i-- + dAtA[i] = 0x18 + } + if x.RevisionNumber != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.RevisionNumber)) + i-- + dAtA[i] = 0x10 + } + if len(x.ChainName) > 0 { + i -= len(x.ChainName) + copy(dAtA[i:], x.ChainName) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainName))) + 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().(*QueryConsensusStateRequest) + 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: QueryConsensusStateRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryConsensusStateRequest: 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 ChainName", 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.ChainName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RevisionNumber", wireType) + } + x.RevisionNumber = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.RevisionNumber |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RevisionHeight", wireType) + } + x.RevisionHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.RevisionHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field LatestHeight", wireType) + } + var v 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++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.LatestHeight = bool(v != 0) + 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_QueryConsensusStateResponse protoreflect.MessageDescriptor + fd_QueryConsensusStateResponse_consensus_state protoreflect.FieldDescriptor + fd_QueryConsensusStateResponse_proof protoreflect.FieldDescriptor + fd_QueryConsensusStateResponse_proof_height protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_query_proto_init() + md_QueryConsensusStateResponse = File_tibc_core_client_v1_query_proto.Messages().ByName("QueryConsensusStateResponse") + fd_QueryConsensusStateResponse_consensus_state = md_QueryConsensusStateResponse.Fields().ByName("consensus_state") + fd_QueryConsensusStateResponse_proof = md_QueryConsensusStateResponse.Fields().ByName("proof") + fd_QueryConsensusStateResponse_proof_height = md_QueryConsensusStateResponse.Fields().ByName("proof_height") +} + +var _ protoreflect.Message = (*fastReflection_QueryConsensusStateResponse)(nil) + +type fastReflection_QueryConsensusStateResponse QueryConsensusStateResponse + +func (x *QueryConsensusStateResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryConsensusStateResponse)(x) +} + +func (x *QueryConsensusStateResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_query_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryConsensusStateResponse_messageType fastReflection_QueryConsensusStateResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryConsensusStateResponse_messageType{} + +type fastReflection_QueryConsensusStateResponse_messageType struct{} + +func (x fastReflection_QueryConsensusStateResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryConsensusStateResponse)(nil) +} +func (x fastReflection_QueryConsensusStateResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryConsensusStateResponse) +} +func (x fastReflection_QueryConsensusStateResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryConsensusStateResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryConsensusStateResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryConsensusStateResponse +} + +// 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_QueryConsensusStateResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryConsensusStateResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryConsensusStateResponse) New() protoreflect.Message { + return new(fastReflection_QueryConsensusStateResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryConsensusStateResponse) Interface() protoreflect.ProtoMessage { + return (*QueryConsensusStateResponse)(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_QueryConsensusStateResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ConsensusState != nil { + value := protoreflect.ValueOfMessage(x.ConsensusState.ProtoReflect()) + if !f(fd_QueryConsensusStateResponse_consensus_state, value) { + return + } + } + if len(x.Proof) != 0 { + value := protoreflect.ValueOfBytes(x.Proof) + if !f(fd_QueryConsensusStateResponse_proof, value) { + return + } + } + if x.ProofHeight != nil { + value := protoreflect.ValueOfMessage(x.ProofHeight.ProtoReflect()) + if !f(fd_QueryConsensusStateResponse_proof_height, 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_QueryConsensusStateResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.QueryConsensusStateResponse.consensus_state": + return x.ConsensusState != nil + case "tibc.core.client.v1.QueryConsensusStateResponse.proof": + return len(x.Proof) != 0 + case "tibc.core.client.v1.QueryConsensusStateResponse.proof_height": + return x.ProofHeight != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStateResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStateResponse 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_QueryConsensusStateResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.QueryConsensusStateResponse.consensus_state": + x.ConsensusState = nil + case "tibc.core.client.v1.QueryConsensusStateResponse.proof": + x.Proof = nil + case "tibc.core.client.v1.QueryConsensusStateResponse.proof_height": + x.ProofHeight = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStateResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStateResponse 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_QueryConsensusStateResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.QueryConsensusStateResponse.consensus_state": + value := x.ConsensusState + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.client.v1.QueryConsensusStateResponse.proof": + value := x.Proof + return protoreflect.ValueOfBytes(value) + case "tibc.core.client.v1.QueryConsensusStateResponse.proof_height": + value := x.ProofHeight + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStateResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStateResponse 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_QueryConsensusStateResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.QueryConsensusStateResponse.consensus_state": + x.ConsensusState = value.Message().Interface().(*anypb.Any) + case "tibc.core.client.v1.QueryConsensusStateResponse.proof": + x.Proof = value.Bytes() + case "tibc.core.client.v1.QueryConsensusStateResponse.proof_height": + x.ProofHeight = value.Message().Interface().(*Height) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStateResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStateResponse 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_QueryConsensusStateResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.QueryConsensusStateResponse.consensus_state": + if x.ConsensusState == nil { + x.ConsensusState = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.ConsensusState.ProtoReflect()) + case "tibc.core.client.v1.QueryConsensusStateResponse.proof_height": + if x.ProofHeight == nil { + x.ProofHeight = new(Height) + } + return protoreflect.ValueOfMessage(x.ProofHeight.ProtoReflect()) + case "tibc.core.client.v1.QueryConsensusStateResponse.proof": + panic(fmt.Errorf("field proof of message tibc.core.client.v1.QueryConsensusStateResponse is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStateResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStateResponse 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_QueryConsensusStateResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.QueryConsensusStateResponse.consensus_state": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.client.v1.QueryConsensusStateResponse.proof": + return protoreflect.ValueOfBytes(nil) + case "tibc.core.client.v1.QueryConsensusStateResponse.proof_height": + m := new(Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStateResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStateResponse 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_QueryConsensusStateResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.QueryConsensusStateResponse", 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_QueryConsensusStateResponse) 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_QueryConsensusStateResponse) 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_QueryConsensusStateResponse) 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_QueryConsensusStateResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryConsensusStateResponse) + 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.ConsensusState != nil { + l = options.Size(x.ConsensusState) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Proof) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ProofHeight != nil { + l = options.Size(x.ProofHeight) + 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().(*QueryConsensusStateResponse) + 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.ProofHeight != nil { + encoded, err := options.Marshal(x.ProofHeight) + 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.Proof) > 0 { + i -= len(x.Proof) + copy(dAtA[i:], x.Proof) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Proof))) + i-- + dAtA[i] = 0x12 + } + if x.ConsensusState != nil { + encoded, err := options.Marshal(x.ConsensusState) + 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().(*QueryConsensusStateResponse) + 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: QueryConsensusStateResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryConsensusStateResponse: 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 ConsensusState", 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.ConsensusState == nil { + x.ConsensusState = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ConsensusState); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Proof = append(x.Proof[:0], dAtA[iNdEx:postIndex]...) + if x.Proof == nil { + x.Proof = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", 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.ProofHeight == nil { + x.ProofHeight = &Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ProofHeight); 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_QueryConsensusStatesRequest protoreflect.MessageDescriptor + fd_QueryConsensusStatesRequest_chain_name protoreflect.FieldDescriptor + fd_QueryConsensusStatesRequest_pagination protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_query_proto_init() + md_QueryConsensusStatesRequest = File_tibc_core_client_v1_query_proto.Messages().ByName("QueryConsensusStatesRequest") + fd_QueryConsensusStatesRequest_chain_name = md_QueryConsensusStatesRequest.Fields().ByName("chain_name") + fd_QueryConsensusStatesRequest_pagination = md_QueryConsensusStatesRequest.Fields().ByName("pagination") +} + +var _ protoreflect.Message = (*fastReflection_QueryConsensusStatesRequest)(nil) + +type fastReflection_QueryConsensusStatesRequest QueryConsensusStatesRequest + +func (x *QueryConsensusStatesRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryConsensusStatesRequest)(x) +} + +func (x *QueryConsensusStatesRequest) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_query_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_QueryConsensusStatesRequest_messageType fastReflection_QueryConsensusStatesRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryConsensusStatesRequest_messageType{} + +type fastReflection_QueryConsensusStatesRequest_messageType struct{} + +func (x fastReflection_QueryConsensusStatesRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryConsensusStatesRequest)(nil) +} +func (x fastReflection_QueryConsensusStatesRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryConsensusStatesRequest) +} +func (x fastReflection_QueryConsensusStatesRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryConsensusStatesRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryConsensusStatesRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryConsensusStatesRequest +} + +// 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_QueryConsensusStatesRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryConsensusStatesRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryConsensusStatesRequest) New() protoreflect.Message { + return new(fastReflection_QueryConsensusStatesRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryConsensusStatesRequest) Interface() protoreflect.ProtoMessage { + return (*QueryConsensusStatesRequest)(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_QueryConsensusStatesRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ChainName != "" { + value := protoreflect.ValueOfString(x.ChainName) + if !f(fd_QueryConsensusStatesRequest_chain_name, value) { + return + } + } + if x.Pagination != nil { + value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + if !f(fd_QueryConsensusStatesRequest_pagination, 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_QueryConsensusStatesRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.QueryConsensusStatesRequest.chain_name": + return x.ChainName != "" + case "tibc.core.client.v1.QueryConsensusStatesRequest.pagination": + return x.Pagination != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStatesRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStatesRequest 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_QueryConsensusStatesRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.QueryConsensusStatesRequest.chain_name": + x.ChainName = "" + case "tibc.core.client.v1.QueryConsensusStatesRequest.pagination": + x.Pagination = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStatesRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStatesRequest 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_QueryConsensusStatesRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.QueryConsensusStatesRequest.chain_name": + value := x.ChainName + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.QueryConsensusStatesRequest.pagination": + value := x.Pagination + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStatesRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStatesRequest 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_QueryConsensusStatesRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.QueryConsensusStatesRequest.chain_name": + x.ChainName = value.Interface().(string) + case "tibc.core.client.v1.QueryConsensusStatesRequest.pagination": + x.Pagination = value.Message().Interface().(*v1beta1.PageRequest) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStatesRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStatesRequest 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_QueryConsensusStatesRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.QueryConsensusStatesRequest.pagination": + if x.Pagination == nil { + x.Pagination = new(v1beta1.PageRequest) + } + return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + case "tibc.core.client.v1.QueryConsensusStatesRequest.chain_name": + panic(fmt.Errorf("field chain_name of message tibc.core.client.v1.QueryConsensusStatesRequest is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStatesRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStatesRequest 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_QueryConsensusStatesRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.QueryConsensusStatesRequest.chain_name": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.QueryConsensusStatesRequest.pagination": + m := new(v1beta1.PageRequest) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStatesRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStatesRequest 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_QueryConsensusStatesRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.QueryConsensusStatesRequest", 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_QueryConsensusStatesRequest) 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_QueryConsensusStatesRequest) 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_QueryConsensusStatesRequest) 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_QueryConsensusStatesRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryConsensusStatesRequest) + 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.ChainName) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Pagination != nil { + l = options.Size(x.Pagination) + 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().(*QueryConsensusStatesRequest) + 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.Pagination != nil { + encoded, err := options.Marshal(x.Pagination) + 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.ChainName) > 0 { + i -= len(x.ChainName) + copy(dAtA[i:], x.ChainName) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainName))) + 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().(*QueryConsensusStatesRequest) + 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: QueryConsensusStatesRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryConsensusStatesRequest: 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 ChainName", 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.ChainName = 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 Pagination", 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.Pagination == nil { + x.Pagination = &v1beta1.PageRequest{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); 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 = (*_QueryConsensusStatesResponse_1_list)(nil) + +type _QueryConsensusStatesResponse_1_list struct { + list *[]*ConsensusStateWithHeight +} + +func (x *_QueryConsensusStatesResponse_1_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_QueryConsensusStatesResponse_1_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_QueryConsensusStatesResponse_1_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*ConsensusStateWithHeight) + (*x.list)[i] = concreteValue +} + +func (x *_QueryConsensusStatesResponse_1_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*ConsensusStateWithHeight) + *x.list = append(*x.list, concreteValue) +} + +func (x *_QueryConsensusStatesResponse_1_list) AppendMutable() protoreflect.Value { + v := new(ConsensusStateWithHeight) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_QueryConsensusStatesResponse_1_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_QueryConsensusStatesResponse_1_list) NewElement() protoreflect.Value { + v := new(ConsensusStateWithHeight) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_QueryConsensusStatesResponse_1_list) IsValid() bool { + return x.list != nil +} + +var ( + md_QueryConsensusStatesResponse protoreflect.MessageDescriptor + fd_QueryConsensusStatesResponse_consensus_states protoreflect.FieldDescriptor + fd_QueryConsensusStatesResponse_pagination protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_query_proto_init() + md_QueryConsensusStatesResponse = File_tibc_core_client_v1_query_proto.Messages().ByName("QueryConsensusStatesResponse") + fd_QueryConsensusStatesResponse_consensus_states = md_QueryConsensusStatesResponse.Fields().ByName("consensus_states") + fd_QueryConsensusStatesResponse_pagination = md_QueryConsensusStatesResponse.Fields().ByName("pagination") +} + +var _ protoreflect.Message = (*fastReflection_QueryConsensusStatesResponse)(nil) + +type fastReflection_QueryConsensusStatesResponse QueryConsensusStatesResponse + +func (x *QueryConsensusStatesResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryConsensusStatesResponse)(x) +} + +func (x *QueryConsensusStatesResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_query_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryConsensusStatesResponse_messageType fastReflection_QueryConsensusStatesResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryConsensusStatesResponse_messageType{} + +type fastReflection_QueryConsensusStatesResponse_messageType struct{} + +func (x fastReflection_QueryConsensusStatesResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryConsensusStatesResponse)(nil) +} +func (x fastReflection_QueryConsensusStatesResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryConsensusStatesResponse) +} +func (x fastReflection_QueryConsensusStatesResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryConsensusStatesResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryConsensusStatesResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryConsensusStatesResponse +} + +// 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_QueryConsensusStatesResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryConsensusStatesResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryConsensusStatesResponse) New() protoreflect.Message { + return new(fastReflection_QueryConsensusStatesResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryConsensusStatesResponse) Interface() protoreflect.ProtoMessage { + return (*QueryConsensusStatesResponse)(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_QueryConsensusStatesResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.ConsensusStates) != 0 { + value := protoreflect.ValueOfList(&_QueryConsensusStatesResponse_1_list{list: &x.ConsensusStates}) + if !f(fd_QueryConsensusStatesResponse_consensus_states, value) { + return + } + } + if x.Pagination != nil { + value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + if !f(fd_QueryConsensusStatesResponse_pagination, 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_QueryConsensusStatesResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.QueryConsensusStatesResponse.consensus_states": + return len(x.ConsensusStates) != 0 + case "tibc.core.client.v1.QueryConsensusStatesResponse.pagination": + return x.Pagination != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStatesResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStatesResponse 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_QueryConsensusStatesResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.QueryConsensusStatesResponse.consensus_states": + x.ConsensusStates = nil + case "tibc.core.client.v1.QueryConsensusStatesResponse.pagination": + x.Pagination = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStatesResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStatesResponse 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_QueryConsensusStatesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.QueryConsensusStatesResponse.consensus_states": + if len(x.ConsensusStates) == 0 { + return protoreflect.ValueOfList(&_QueryConsensusStatesResponse_1_list{}) + } + listValue := &_QueryConsensusStatesResponse_1_list{list: &x.ConsensusStates} + return protoreflect.ValueOfList(listValue) + case "tibc.core.client.v1.QueryConsensusStatesResponse.pagination": + value := x.Pagination + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStatesResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStatesResponse 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_QueryConsensusStatesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.QueryConsensusStatesResponse.consensus_states": + lv := value.List() + clv := lv.(*_QueryConsensusStatesResponse_1_list) + x.ConsensusStates = *clv.list + case "tibc.core.client.v1.QueryConsensusStatesResponse.pagination": + x.Pagination = value.Message().Interface().(*v1beta1.PageResponse) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStatesResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStatesResponse 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_QueryConsensusStatesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.QueryConsensusStatesResponse.consensus_states": + if x.ConsensusStates == nil { + x.ConsensusStates = []*ConsensusStateWithHeight{} + } + value := &_QueryConsensusStatesResponse_1_list{list: &x.ConsensusStates} + return protoreflect.ValueOfList(value) + case "tibc.core.client.v1.QueryConsensusStatesResponse.pagination": + if x.Pagination == nil { + x.Pagination = new(v1beta1.PageResponse) + } + return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStatesResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStatesResponse 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_QueryConsensusStatesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.QueryConsensusStatesResponse.consensus_states": + list := []*ConsensusStateWithHeight{} + return protoreflect.ValueOfList(&_QueryConsensusStatesResponse_1_list{list: &list}) + case "tibc.core.client.v1.QueryConsensusStatesResponse.pagination": + m := new(v1beta1.PageResponse) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryConsensusStatesResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryConsensusStatesResponse 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_QueryConsensusStatesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.QueryConsensusStatesResponse", 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_QueryConsensusStatesResponse) 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_QueryConsensusStatesResponse) 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_QueryConsensusStatesResponse) 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_QueryConsensusStatesResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryConsensusStatesResponse) + 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.ConsensusStates) > 0 { + for _, e := range x.ConsensusStates { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.Pagination != nil { + l = options.Size(x.Pagination) + 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().(*QueryConsensusStatesResponse) + 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.Pagination != nil { + encoded, err := options.Marshal(x.Pagination) + 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.ConsensusStates) > 0 { + for iNdEx := len(x.ConsensusStates) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.ConsensusStates[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().(*QueryConsensusStatesResponse) + 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: QueryConsensusStatesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryConsensusStatesResponse: 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 ConsensusStates", 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.ConsensusStates = append(x.ConsensusStates, &ConsensusStateWithHeight{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ConsensusStates[len(x.ConsensusStates)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", 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.Pagination == nil { + x.Pagination = &v1beta1.PageResponse{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); 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_QueryRelayersRequest protoreflect.MessageDescriptor + fd_QueryRelayersRequest_chain_name protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_query_proto_init() + md_QueryRelayersRequest = File_tibc_core_client_v1_query_proto.Messages().ByName("QueryRelayersRequest") + fd_QueryRelayersRequest_chain_name = md_QueryRelayersRequest.Fields().ByName("chain_name") +} + +var _ protoreflect.Message = (*fastReflection_QueryRelayersRequest)(nil) + +type fastReflection_QueryRelayersRequest QueryRelayersRequest + +func (x *QueryRelayersRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryRelayersRequest)(x) +} + +func (x *QueryRelayersRequest) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_query_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_QueryRelayersRequest_messageType fastReflection_QueryRelayersRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryRelayersRequest_messageType{} + +type fastReflection_QueryRelayersRequest_messageType struct{} + +func (x fastReflection_QueryRelayersRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryRelayersRequest)(nil) +} +func (x fastReflection_QueryRelayersRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryRelayersRequest) +} +func (x fastReflection_QueryRelayersRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryRelayersRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryRelayersRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryRelayersRequest +} + +// 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_QueryRelayersRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryRelayersRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryRelayersRequest) New() protoreflect.Message { + return new(fastReflection_QueryRelayersRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryRelayersRequest) Interface() protoreflect.ProtoMessage { + return (*QueryRelayersRequest)(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_QueryRelayersRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ChainName != "" { + value := protoreflect.ValueOfString(x.ChainName) + if !f(fd_QueryRelayersRequest_chain_name, 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_QueryRelayersRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.QueryRelayersRequest.chain_name": + return x.ChainName != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryRelayersRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryRelayersRequest 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_QueryRelayersRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.QueryRelayersRequest.chain_name": + x.ChainName = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryRelayersRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryRelayersRequest 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_QueryRelayersRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.QueryRelayersRequest.chain_name": + value := x.ChainName + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryRelayersRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryRelayersRequest 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_QueryRelayersRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.QueryRelayersRequest.chain_name": + x.ChainName = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryRelayersRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryRelayersRequest 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_QueryRelayersRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.QueryRelayersRequest.chain_name": + panic(fmt.Errorf("field chain_name of message tibc.core.client.v1.QueryRelayersRequest is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryRelayersRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryRelayersRequest 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_QueryRelayersRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.QueryRelayersRequest.chain_name": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryRelayersRequest")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryRelayersRequest 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_QueryRelayersRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.QueryRelayersRequest", 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_QueryRelayersRequest) 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_QueryRelayersRequest) 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_QueryRelayersRequest) 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_QueryRelayersRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryRelayersRequest) + 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.ChainName) + 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().(*QueryRelayersRequest) + 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.ChainName) > 0 { + i -= len(x.ChainName) + copy(dAtA[i:], x.ChainName) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainName))) + 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().(*QueryRelayersRequest) + 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: QueryRelayersRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryRelayersRequest: 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 ChainName", 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.ChainName = 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 = (*_QueryRelayersResponse_1_list)(nil) + +type _QueryRelayersResponse_1_list struct { + list *[]string +} + +func (x *_QueryRelayersResponse_1_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_QueryRelayersResponse_1_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfString((*x.list)[i]) +} + +func (x *_QueryRelayersResponse_1_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_QueryRelayersResponse_1_list) Append(value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_QueryRelayersResponse_1_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message QueryRelayersResponse at list field Relayers as it is not of Message kind")) +} + +func (x *_QueryRelayersResponse_1_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_QueryRelayersResponse_1_list) NewElement() protoreflect.Value { + v := "" + return protoreflect.ValueOfString(v) +} + +func (x *_QueryRelayersResponse_1_list) IsValid() bool { + return x.list != nil +} + +var ( + md_QueryRelayersResponse protoreflect.MessageDescriptor + fd_QueryRelayersResponse_relayers protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_query_proto_init() + md_QueryRelayersResponse = File_tibc_core_client_v1_query_proto.Messages().ByName("QueryRelayersResponse") + fd_QueryRelayersResponse_relayers = md_QueryRelayersResponse.Fields().ByName("relayers") +} + +var _ protoreflect.Message = (*fastReflection_QueryRelayersResponse)(nil) + +type fastReflection_QueryRelayersResponse QueryRelayersResponse + +func (x *QueryRelayersResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryRelayersResponse)(x) +} + +func (x *QueryRelayersResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_v1_query_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryRelayersResponse_messageType fastReflection_QueryRelayersResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryRelayersResponse_messageType{} + +type fastReflection_QueryRelayersResponse_messageType struct{} + +func (x fastReflection_QueryRelayersResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryRelayersResponse)(nil) +} +func (x fastReflection_QueryRelayersResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryRelayersResponse) +} +func (x fastReflection_QueryRelayersResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryRelayersResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryRelayersResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryRelayersResponse +} + +// 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_QueryRelayersResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryRelayersResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryRelayersResponse) New() protoreflect.Message { + return new(fastReflection_QueryRelayersResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryRelayersResponse) Interface() protoreflect.ProtoMessage { + return (*QueryRelayersResponse)(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_QueryRelayersResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.Relayers) != 0 { + value := protoreflect.ValueOfList(&_QueryRelayersResponse_1_list{list: &x.Relayers}) + if !f(fd_QueryRelayersResponse_relayers, 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_QueryRelayersResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.QueryRelayersResponse.relayers": + return len(x.Relayers) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryRelayersResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryRelayersResponse 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_QueryRelayersResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.QueryRelayersResponse.relayers": + x.Relayers = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryRelayersResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryRelayersResponse 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_QueryRelayersResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.QueryRelayersResponse.relayers": + if len(x.Relayers) == 0 { + return protoreflect.ValueOfList(&_QueryRelayersResponse_1_list{}) + } + listValue := &_QueryRelayersResponse_1_list{list: &x.Relayers} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryRelayersResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryRelayersResponse 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_QueryRelayersResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.QueryRelayersResponse.relayers": + lv := value.List() + clv := lv.(*_QueryRelayersResponse_1_list) + x.Relayers = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryRelayersResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryRelayersResponse 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_QueryRelayersResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.QueryRelayersResponse.relayers": + if x.Relayers == nil { + x.Relayers = []string{} + } + value := &_QueryRelayersResponse_1_list{list: &x.Relayers} + return protoreflect.ValueOfList(value) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryRelayersResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryRelayersResponse 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_QueryRelayersResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.QueryRelayersResponse.relayers": + list := []string{} + return protoreflect.ValueOfList(&_QueryRelayersResponse_1_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.QueryRelayersResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.QueryRelayersResponse 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_QueryRelayersResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.QueryRelayersResponse", 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_QueryRelayersResponse) 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_QueryRelayersResponse) 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_QueryRelayersResponse) 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_QueryRelayersResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryRelayersResponse) + 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.Relayers) > 0 { + for _, s := range x.Relayers { + l = len(s) + 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().(*QueryRelayersResponse) + 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.Relayers) > 0 { + for iNdEx := len(x.Relayers) - 1; iNdEx >= 0; iNdEx-- { + i -= len(x.Relayers[iNdEx]) + copy(dAtA[i:], x.Relayers[iNdEx]) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Relayers[iNdEx]))) + 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().(*QueryRelayersResponse) + 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: QueryRelayersResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryRelayersResponse: 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 Relayers", 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.Relayers = append(x.Relayers, 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, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: tibc/core/client/v1/query.proto + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// QueryClientStateRequest is the request type for the Query/ClientState RPC +// method +type QueryClientStateRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // client state unique identifier + ChainName string `protobuf:"bytes,1,opt,name=chain_name,json=chainName,proto3" json:"chain_name,omitempty"` +} + +func (x *QueryClientStateRequest) Reset() { + *x = QueryClientStateRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_query_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryClientStateRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryClientStateRequest) ProtoMessage() {} + +// Deprecated: Use QueryClientStateRequest.ProtoReflect.Descriptor instead. +func (*QueryClientStateRequest) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_query_proto_rawDescGZIP(), []int{0} +} + +func (x *QueryClientStateRequest) GetChainName() string { + if x != nil { + return x.ChainName + } + return "" +} + +// QueryClientStateResponse is the response type for the Query/ClientState RPC +// method. Besides the client state, it includes a proof and the height from +// which the proof was retrieved. +type QueryClientStateResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // client state associated with the request identifier + ClientState *anypb.Any `protobuf:"bytes,1,opt,name=client_state,json=clientState,proto3" json:"client_state,omitempty"` + // merkle proof of existence + Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"` + // height at which the proof was retrieved + ProofHeight *Height `protobuf:"bytes,3,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty"` +} + +func (x *QueryClientStateResponse) Reset() { + *x = QueryClientStateResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_query_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryClientStateResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryClientStateResponse) ProtoMessage() {} + +// Deprecated: Use QueryClientStateResponse.ProtoReflect.Descriptor instead. +func (*QueryClientStateResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_query_proto_rawDescGZIP(), []int{1} +} + +func (x *QueryClientStateResponse) GetClientState() *anypb.Any { + if x != nil { + return x.ClientState + } + return nil +} + +func (x *QueryClientStateResponse) GetProof() []byte { + if x != nil { + return x.Proof + } + return nil +} + +func (x *QueryClientStateResponse) GetProofHeight() *Height { + if x != nil { + return x.ProofHeight + } + return nil +} + +// QueryClientStatesRequest is the request type for the Query/ClientStates RPC +// method +type QueryClientStatesRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // pagination request + Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (x *QueryClientStatesRequest) Reset() { + *x = QueryClientStatesRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_query_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryClientStatesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryClientStatesRequest) ProtoMessage() {} + +// Deprecated: Use QueryClientStatesRequest.ProtoReflect.Descriptor instead. +func (*QueryClientStatesRequest) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_query_proto_rawDescGZIP(), []int{2} +} + +func (x *QueryClientStatesRequest) GetPagination() *v1beta1.PageRequest { + if x != nil { + return x.Pagination + } + return nil +} + +// QueryClientStatesResponse is the response type for the Query/ClientStates RPC +// method. +type QueryClientStatesResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // list of stored ClientStates of the chain. + ClientStates []*IdentifiedClientState `protobuf:"bytes,1,rep,name=client_states,json=clientStates,proto3" json:"client_states,omitempty"` + // pagination response + Pagination *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (x *QueryClientStatesResponse) Reset() { + *x = QueryClientStatesResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_query_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryClientStatesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryClientStatesResponse) ProtoMessage() {} + +// Deprecated: Use QueryClientStatesResponse.ProtoReflect.Descriptor instead. +func (*QueryClientStatesResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_query_proto_rawDescGZIP(), []int{3} +} + +func (x *QueryClientStatesResponse) GetClientStates() []*IdentifiedClientState { + if x != nil { + return x.ClientStates + } + return nil +} + +func (x *QueryClientStatesResponse) GetPagination() *v1beta1.PageResponse { + if x != nil { + return x.Pagination + } + return nil +} + +// QueryConsensusStateRequest is the request type for the Query/ConsensusState +// RPC method. Besides the consensus state, it includes a proof and the height +// from which the proof was retrieved. +type QueryConsensusStateRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // client identifier + ChainName string `protobuf:"bytes,1,opt,name=chain_name,json=chainName,proto3" json:"chain_name,omitempty"` + // consensus state revision number + RevisionNumber uint64 `protobuf:"varint,2,opt,name=revision_number,json=revisionNumber,proto3" json:"revision_number,omitempty"` + // consensus state revision height + RevisionHeight uint64 `protobuf:"varint,3,opt,name=revision_height,json=revisionHeight,proto3" json:"revision_height,omitempty"` + // latest_height overrrides the height field and queries the latest stored + // ConsensusState + LatestHeight bool `protobuf:"varint,4,opt,name=latest_height,json=latestHeight,proto3" json:"latest_height,omitempty"` +} + +func (x *QueryConsensusStateRequest) Reset() { + *x = QueryConsensusStateRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_query_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryConsensusStateRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryConsensusStateRequest) ProtoMessage() {} + +// Deprecated: Use QueryConsensusStateRequest.ProtoReflect.Descriptor instead. +func (*QueryConsensusStateRequest) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_query_proto_rawDescGZIP(), []int{4} +} + +func (x *QueryConsensusStateRequest) GetChainName() string { + if x != nil { + return x.ChainName + } + return "" +} + +func (x *QueryConsensusStateRequest) GetRevisionNumber() uint64 { + if x != nil { + return x.RevisionNumber + } + return 0 +} + +func (x *QueryConsensusStateRequest) GetRevisionHeight() uint64 { + if x != nil { + return x.RevisionHeight + } + return 0 +} + +func (x *QueryConsensusStateRequest) GetLatestHeight() bool { + if x != nil { + return x.LatestHeight + } + return false +} + +// QueryConsensusStateResponse is the response type for the Query/ConsensusState +// RPC method +type QueryConsensusStateResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // consensus state associated with the client identifier at the given height + ConsensusState *anypb.Any `protobuf:"bytes,1,opt,name=consensus_state,json=consensusState,proto3" json:"consensus_state,omitempty"` + // merkle proof of existence + Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"` + // height at which the proof was retrieved + ProofHeight *Height `protobuf:"bytes,3,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty"` +} + +func (x *QueryConsensusStateResponse) Reset() { + *x = QueryConsensusStateResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_query_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryConsensusStateResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryConsensusStateResponse) ProtoMessage() {} + +// Deprecated: Use QueryConsensusStateResponse.ProtoReflect.Descriptor instead. +func (*QueryConsensusStateResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_query_proto_rawDescGZIP(), []int{5} +} + +func (x *QueryConsensusStateResponse) GetConsensusState() *anypb.Any { + if x != nil { + return x.ConsensusState + } + return nil +} + +func (x *QueryConsensusStateResponse) GetProof() []byte { + if x != nil { + return x.Proof + } + return nil +} + +func (x *QueryConsensusStateResponse) GetProofHeight() *Height { + if x != nil { + return x.ProofHeight + } + return nil +} + +// QueryConsensusStatesRequest is the request type for the Query/ConsensusStates +// RPC method. +type QueryConsensusStatesRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // client identifier + ChainName string `protobuf:"bytes,1,opt,name=chain_name,json=chainName,proto3" json:"chain_name,omitempty"` + // pagination request + Pagination *v1beta1.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (x *QueryConsensusStatesRequest) Reset() { + *x = QueryConsensusStatesRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_query_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryConsensusStatesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryConsensusStatesRequest) ProtoMessage() {} + +// Deprecated: Use QueryConsensusStatesRequest.ProtoReflect.Descriptor instead. +func (*QueryConsensusStatesRequest) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_query_proto_rawDescGZIP(), []int{6} +} + +func (x *QueryConsensusStatesRequest) GetChainName() string { + if x != nil { + return x.ChainName + } + return "" +} + +func (x *QueryConsensusStatesRequest) GetPagination() *v1beta1.PageRequest { + if x != nil { + return x.Pagination + } + return nil +} + +// QueryConsensusStatesResponse is the response type for the +// Query/ConsensusStates RPC method +type QueryConsensusStatesResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // consensus states associated with the identifier + ConsensusStates []*ConsensusStateWithHeight `protobuf:"bytes,1,rep,name=consensus_states,json=consensusStates,proto3" json:"consensus_states,omitempty"` + // pagination response + Pagination *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (x *QueryConsensusStatesResponse) Reset() { + *x = QueryConsensusStatesResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_query_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryConsensusStatesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryConsensusStatesResponse) ProtoMessage() {} + +// Deprecated: Use QueryConsensusStatesResponse.ProtoReflect.Descriptor instead. +func (*QueryConsensusStatesResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_query_proto_rawDescGZIP(), []int{7} +} + +func (x *QueryConsensusStatesResponse) GetConsensusStates() []*ConsensusStateWithHeight { + if x != nil { + return x.ConsensusStates + } + return nil +} + +func (x *QueryConsensusStatesResponse) GetPagination() *v1beta1.PageResponse { + if x != nil { + return x.Pagination + } + return nil +} + +// QueryRelayersRequest is the request type for the Query/Relayers +// RPC method. +type QueryRelayersRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // client identifier + ChainName string `protobuf:"bytes,1,opt,name=chain_name,json=chainName,proto3" json:"chain_name,omitempty"` +} + +func (x *QueryRelayersRequest) Reset() { + *x = QueryRelayersRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_query_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryRelayersRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryRelayersRequest) ProtoMessage() {} + +// Deprecated: Use QueryRelayersRequest.ProtoReflect.Descriptor instead. +func (*QueryRelayersRequest) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_query_proto_rawDescGZIP(), []int{8} +} + +func (x *QueryRelayersRequest) GetChainName() string { + if x != nil { + return x.ChainName + } + return "" +} + +// QueryConsensusStatesResponse is the response type for the +// Query/Relayers RPC method +type QueryRelayersResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // relayers address associated with the client + Relayers []string `protobuf:"bytes,1,rep,name=relayers,proto3" json:"relayers,omitempty"` +} + +func (x *QueryRelayersResponse) Reset() { + *x = QueryRelayersResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_query_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryRelayersResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryRelayersResponse) ProtoMessage() {} + +// Deprecated: Use QueryRelayersResponse.ProtoReflect.Descriptor instead. +func (*QueryRelayersResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_query_proto_rawDescGZIP(), []int{9} +} + +func (x *QueryRelayersResponse) GetRelayers() []string { + if x != nil { + return x.Relayers + } + return nil +} + +var File_tibc_core_client_v1_query_proto protoreflect.FileDescriptor + +var file_tibc_core_client_v1_query_proto_rawDesc = []byte{ + 0x0a, 0x1f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x13, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x1a, 0x2a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, + 0x61, 0x73, 0x65, 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, + 0x31, 0x2f, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x20, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x63, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 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, + 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, + 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 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, 0x22, 0x38, 0x0a, 0x17, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, + 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x09, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0xaf, 0x01, + 0x0a, 0x18, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, + 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x37, 0x0a, 0x0c, 0x63, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 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, 0x0b, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, + 0x61, 0x74, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0c, 0x52, 0x05, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x44, 0x0a, 0x0c, 0x70, 0x72, 0x6f, + 0x6f, 0x66, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1b, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, 0x04, 0xc8, 0xde, + 0x1f, 0x00, 0x52, 0x0b, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, + 0x62, 0x0a, 0x18, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, + 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70, + 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, + 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x22, 0xd5, 0x01, 0x0a, 0x19, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x6f, 0x0a, 0x0d, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, + 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x64, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, + 0x74, 0x61, 0x74, 0x65, 0x42, 0x1e, 0xc8, 0xde, 0x1f, 0x00, 0xaa, 0xdf, 0x1f, 0x16, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x64, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, + 0x61, 0x74, 0x65, 0x73, 0x52, 0x0c, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, + 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, + 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, + 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xb2, 0x01, 0x0a, 0x1a, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, + 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x68, + 0x61, 0x69, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x76, + 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x04, 0x52, 0x0e, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x4e, 0x75, 0x6d, 0x62, + 0x65, 0x72, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x68, + 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x72, 0x65, 0x76, + 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x6c, + 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x0c, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, + 0x22, 0xb8, 0x01, 0x0a, 0x1b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x73, 0x65, 0x6e, + 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x3d, 0x0a, 0x0f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x5f, 0x73, 0x74, + 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 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, + 0x0e, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, + 0x14, 0x0a, 0x05, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, + 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x44, 0x0a, 0x0c, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x68, + 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x74, 0x69, + 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, + 0x31, 0x2e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0b, + 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x84, 0x01, 0x0a, 0x1b, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, + 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x63, + 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x09, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, + 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, + 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, + 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x22, 0xc7, 0x01, 0x0a, 0x1c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x73, + 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x5e, 0x0a, 0x10, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, + 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, + 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, + 0x74, 0x65, 0x57, 0x69, 0x74, 0x68, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, 0x04, 0xc8, 0xde, + 0x1f, 0x00, 0x52, 0x0f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, + 0x74, 0x65, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, + 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, + 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x35, 0x0a, 0x14, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4e, + 0x61, 0x6d, 0x65, 0x22, 0x33, 0x0a, 0x15, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x6c, 0x61, + 0x79, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, + 0x72, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, + 0x72, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x32, 0x90, 0x07, 0x0a, 0x05, 0x51, 0x75, 0x65, + 0x72, 0x79, 0x12, 0xa7, 0x01, 0x0a, 0x0b, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, + 0x74, 0x65, 0x12, 0x2c, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x2d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x3b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x35, 0x12, 0x33, 0x2f, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, + 0x72, 0x65, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, + 0x31, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x2f, + 0x7b, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12, 0x9d, 0x01, 0x0a, + 0x0c, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x12, 0x2d, 0x2e, + 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, + 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x74, + 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, + 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, + 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2e, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x28, 0x12, 0x26, 0x2f, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, + 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x63, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x12, 0xe7, 0x01, 0x0a, + 0x0e, 0x43, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, + 0x2f, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x73, 0x65, + 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x30, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x73, + 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x72, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x6c, 0x12, 0x6a, 0x2f, 0x69, 0x62, 0x63, + 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x62, + 0x65, 0x74, 0x61, 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x5f, 0x73, + 0x74, 0x61, 0x74, 0x65, 0x73, 0x2f, 0x7b, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, + 0x65, 0x7d, 0x2f, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x2f, 0x7b, 0x72, 0x65, 0x76, + 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x7d, 0x2f, 0x68, 0x65, + 0x69, 0x67, 0x68, 0x74, 0x2f, 0x7b, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x68, + 0x65, 0x69, 0x67, 0x68, 0x74, 0x7d, 0x12, 0xb6, 0x01, 0x0a, 0x0f, 0x43, 0x6f, 0x6e, 0x73, 0x65, + 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x12, 0x30, 0x2e, 0x74, 0x69, 0x62, + 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, + 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, + 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x74, + 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, + 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, + 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x3e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x38, 0x12, 0x36, 0x2f, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, + 0x72, 0x65, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, + 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x5f, 0x73, 0x74, 0x61, 0x74, + 0x65, 0x73, 0x2f, 0x7b, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12, + 0x99, 0x01, 0x0a, 0x08, 0x52, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x12, 0x29, 0x2e, 0x74, + 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, + 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, + 0x65, 0x72, 0x79, 0x52, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x36, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x30, 0x12, 0x2e, 0x2f, 0x69, 0x62, + 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, + 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x72, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x2f, 0x7b, + 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x42, 0xd3, 0x01, 0x0a, 0x17, + 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x42, 0x0a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, + 0x6d, 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, + 0x2d, 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, + 0x65, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x3b, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x54, 0x43, 0x43, 0xaa, 0x02, 0x13, 0x54, 0x69, 0x62, + 0x63, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x56, 0x31, + 0xca, 0x02, 0x13, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x43, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x1f, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x43, 0x6f, + 0x72, 0x65, 0x5c, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x16, 0x54, 0x69, 0x62, 0x63, 0x3a, + 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x3a, 0x3a, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x3a, 0x3a, 0x56, + 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_core_client_v1_query_proto_rawDescOnce sync.Once + file_tibc_core_client_v1_query_proto_rawDescData = file_tibc_core_client_v1_query_proto_rawDesc +) + +func file_tibc_core_client_v1_query_proto_rawDescGZIP() []byte { + file_tibc_core_client_v1_query_proto_rawDescOnce.Do(func() { + file_tibc_core_client_v1_query_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_core_client_v1_query_proto_rawDescData) + }) + return file_tibc_core_client_v1_query_proto_rawDescData +} + +var file_tibc_core_client_v1_query_proto_msgTypes = make([]protoimpl.MessageInfo, 10) +var file_tibc_core_client_v1_query_proto_goTypes = []interface{}{ + (*QueryClientStateRequest)(nil), // 0: tibc.core.client.v1.QueryClientStateRequest + (*QueryClientStateResponse)(nil), // 1: tibc.core.client.v1.QueryClientStateResponse + (*QueryClientStatesRequest)(nil), // 2: tibc.core.client.v1.QueryClientStatesRequest + (*QueryClientStatesResponse)(nil), // 3: tibc.core.client.v1.QueryClientStatesResponse + (*QueryConsensusStateRequest)(nil), // 4: tibc.core.client.v1.QueryConsensusStateRequest + (*QueryConsensusStateResponse)(nil), // 5: tibc.core.client.v1.QueryConsensusStateResponse + (*QueryConsensusStatesRequest)(nil), // 6: tibc.core.client.v1.QueryConsensusStatesRequest + (*QueryConsensusStatesResponse)(nil), // 7: tibc.core.client.v1.QueryConsensusStatesResponse + (*QueryRelayersRequest)(nil), // 8: tibc.core.client.v1.QueryRelayersRequest + (*QueryRelayersResponse)(nil), // 9: tibc.core.client.v1.QueryRelayersResponse + (*anypb.Any)(nil), // 10: google.protobuf.Any + (*Height)(nil), // 11: tibc.core.client.v1.Height + (*v1beta1.PageRequest)(nil), // 12: cosmos.base.query.v1beta1.PageRequest + (*IdentifiedClientState)(nil), // 13: tibc.core.client.v1.IdentifiedClientState + (*v1beta1.PageResponse)(nil), // 14: cosmos.base.query.v1beta1.PageResponse + (*ConsensusStateWithHeight)(nil), // 15: tibc.core.client.v1.ConsensusStateWithHeight +} +var file_tibc_core_client_v1_query_proto_depIdxs = []int32{ + 10, // 0: tibc.core.client.v1.QueryClientStateResponse.client_state:type_name -> google.protobuf.Any + 11, // 1: tibc.core.client.v1.QueryClientStateResponse.proof_height:type_name -> tibc.core.client.v1.Height + 12, // 2: tibc.core.client.v1.QueryClientStatesRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest + 13, // 3: tibc.core.client.v1.QueryClientStatesResponse.client_states:type_name -> tibc.core.client.v1.IdentifiedClientState + 14, // 4: tibc.core.client.v1.QueryClientStatesResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse + 10, // 5: tibc.core.client.v1.QueryConsensusStateResponse.consensus_state:type_name -> google.protobuf.Any + 11, // 6: tibc.core.client.v1.QueryConsensusStateResponse.proof_height:type_name -> tibc.core.client.v1.Height + 12, // 7: tibc.core.client.v1.QueryConsensusStatesRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest + 15, // 8: tibc.core.client.v1.QueryConsensusStatesResponse.consensus_states:type_name -> tibc.core.client.v1.ConsensusStateWithHeight + 14, // 9: tibc.core.client.v1.QueryConsensusStatesResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse + 0, // 10: tibc.core.client.v1.Query.ClientState:input_type -> tibc.core.client.v1.QueryClientStateRequest + 2, // 11: tibc.core.client.v1.Query.ClientStates:input_type -> tibc.core.client.v1.QueryClientStatesRequest + 4, // 12: tibc.core.client.v1.Query.ConsensusState:input_type -> tibc.core.client.v1.QueryConsensusStateRequest + 6, // 13: tibc.core.client.v1.Query.ConsensusStates:input_type -> tibc.core.client.v1.QueryConsensusStatesRequest + 8, // 14: tibc.core.client.v1.Query.Relayers:input_type -> tibc.core.client.v1.QueryRelayersRequest + 1, // 15: tibc.core.client.v1.Query.ClientState:output_type -> tibc.core.client.v1.QueryClientStateResponse + 3, // 16: tibc.core.client.v1.Query.ClientStates:output_type -> tibc.core.client.v1.QueryClientStatesResponse + 5, // 17: tibc.core.client.v1.Query.ConsensusState:output_type -> tibc.core.client.v1.QueryConsensusStateResponse + 7, // 18: tibc.core.client.v1.Query.ConsensusStates:output_type -> tibc.core.client.v1.QueryConsensusStatesResponse + 9, // 19: tibc.core.client.v1.Query.Relayers:output_type -> tibc.core.client.v1.QueryRelayersResponse + 15, // [15:20] is the sub-list for method output_type + 10, // [10:15] is the sub-list for method input_type + 10, // [10:10] is the sub-list for extension type_name + 10, // [10:10] is the sub-list for extension extendee + 0, // [0:10] is the sub-list for field type_name +} + +func init() { file_tibc_core_client_v1_query_proto_init() } +func file_tibc_core_client_v1_query_proto_init() { + if File_tibc_core_client_v1_query_proto != nil { + return + } + file_tibc_core_client_v1_client_proto_init() + if !protoimpl.UnsafeEnabled { + file_tibc_core_client_v1_query_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryClientStateRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_query_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryClientStateResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_query_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryClientStatesRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_query_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryClientStatesResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_query_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryConsensusStateRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_query_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryConsensusStateResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_query_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryConsensusStatesRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_query_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryConsensusStatesResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_query_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryRelayersRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_query_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryRelayersResponse); 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_tibc_core_client_v1_query_proto_rawDesc, + NumEnums: 0, + NumMessages: 10, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_tibc_core_client_v1_query_proto_goTypes, + DependencyIndexes: file_tibc_core_client_v1_query_proto_depIdxs, + MessageInfos: file_tibc_core_client_v1_query_proto_msgTypes, + }.Build() + File_tibc_core_client_v1_query_proto = out.File + file_tibc_core_client_v1_query_proto_rawDesc = nil + file_tibc_core_client_v1_query_proto_goTypes = nil + file_tibc_core_client_v1_query_proto_depIdxs = nil +} diff --git a/api/tibc/core/client/v1/query_grpc.pb.go b/api/tibc/core/client/v1/query_grpc.pb.go new file mode 100644 index 00000000..143440a9 --- /dev/null +++ b/api/tibc/core/client/v1/query_grpc.pb.go @@ -0,0 +1,273 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: tibc/core/client/v1/query.proto + +package clientv1 + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + Query_ClientState_FullMethodName = "/tibc.core.client.v1.Query/ClientState" + Query_ClientStates_FullMethodName = "/tibc.core.client.v1.Query/ClientStates" + Query_ConsensusState_FullMethodName = "/tibc.core.client.v1.Query/ConsensusState" + Query_ConsensusStates_FullMethodName = "/tibc.core.client.v1.Query/ConsensusStates" + Query_Relayers_FullMethodName = "/tibc.core.client.v1.Query/Relayers" +) + +// QueryClient is the client API for Query service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type QueryClient interface { + // ClientState queries an TIBC light client. + ClientState(ctx context.Context, in *QueryClientStateRequest, opts ...grpc.CallOption) (*QueryClientStateResponse, error) + // ClientStates queries all the TIBC light clients of a chain. + ClientStates(ctx context.Context, in *QueryClientStatesRequest, opts ...grpc.CallOption) (*QueryClientStatesResponse, error) + // ConsensusState queries a consensus state associated with a client state at + // a given height. + ConsensusState(ctx context.Context, in *QueryConsensusStateRequest, opts ...grpc.CallOption) (*QueryConsensusStateResponse, error) + // ConsensusStates queries all the consensus state associated with a given + // client. + ConsensusStates(ctx context.Context, in *QueryConsensusStatesRequest, opts ...grpc.CallOption) (*QueryConsensusStatesResponse, error) + // Relayers queries all the relayers associated with a given + // client. + Relayers(ctx context.Context, in *QueryRelayersRequest, opts ...grpc.CallOption) (*QueryRelayersResponse, error) +} + +type queryClient struct { + cc grpc.ClientConnInterface +} + +func NewQueryClient(cc grpc.ClientConnInterface) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) ClientState(ctx context.Context, in *QueryClientStateRequest, opts ...grpc.CallOption) (*QueryClientStateResponse, error) { + out := new(QueryClientStateResponse) + err := c.cc.Invoke(ctx, Query_ClientState_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) ClientStates(ctx context.Context, in *QueryClientStatesRequest, opts ...grpc.CallOption) (*QueryClientStatesResponse, error) { + out := new(QueryClientStatesResponse) + err := c.cc.Invoke(ctx, Query_ClientStates_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) ConsensusState(ctx context.Context, in *QueryConsensusStateRequest, opts ...grpc.CallOption) (*QueryConsensusStateResponse, error) { + out := new(QueryConsensusStateResponse) + err := c.cc.Invoke(ctx, Query_ConsensusState_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) ConsensusStates(ctx context.Context, in *QueryConsensusStatesRequest, opts ...grpc.CallOption) (*QueryConsensusStatesResponse, error) { + out := new(QueryConsensusStatesResponse) + err := c.cc.Invoke(ctx, Query_ConsensusStates_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) Relayers(ctx context.Context, in *QueryRelayersRequest, opts ...grpc.CallOption) (*QueryRelayersResponse, error) { + out := new(QueryRelayersResponse) + err := c.cc.Invoke(ctx, Query_Relayers_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +// All implementations must embed UnimplementedQueryServer +// for forward compatibility +type QueryServer interface { + // ClientState queries an TIBC light client. + ClientState(context.Context, *QueryClientStateRequest) (*QueryClientStateResponse, error) + // ClientStates queries all the TIBC light clients of a chain. + ClientStates(context.Context, *QueryClientStatesRequest) (*QueryClientStatesResponse, error) + // ConsensusState queries a consensus state associated with a client state at + // a given height. + ConsensusState(context.Context, *QueryConsensusStateRequest) (*QueryConsensusStateResponse, error) + // ConsensusStates queries all the consensus state associated with a given + // client. + ConsensusStates(context.Context, *QueryConsensusStatesRequest) (*QueryConsensusStatesResponse, error) + // Relayers queries all the relayers associated with a given + // client. + Relayers(context.Context, *QueryRelayersRequest) (*QueryRelayersResponse, error) + mustEmbedUnimplementedQueryServer() +} + +// UnimplementedQueryServer must be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct { +} + +func (UnimplementedQueryServer) ClientState(context.Context, *QueryClientStateRequest) (*QueryClientStateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ClientState not implemented") +} +func (UnimplementedQueryServer) ClientStates(context.Context, *QueryClientStatesRequest) (*QueryClientStatesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ClientStates not implemented") +} +func (UnimplementedQueryServer) ConsensusState(context.Context, *QueryConsensusStateRequest) (*QueryConsensusStateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ConsensusState not implemented") +} +func (UnimplementedQueryServer) ConsensusStates(context.Context, *QueryConsensusStatesRequest) (*QueryConsensusStatesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ConsensusStates not implemented") +} +func (UnimplementedQueryServer) Relayers(context.Context, *QueryRelayersRequest) (*QueryRelayersResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Relayers not implemented") +} +func (UnimplementedQueryServer) mustEmbedUnimplementedQueryServer() {} + +// UnsafeQueryServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to QueryServer will +// result in compilation errors. +type UnsafeQueryServer interface { + mustEmbedUnimplementedQueryServer() +} + +func RegisterQueryServer(s grpc.ServiceRegistrar, srv QueryServer) { + s.RegisterService(&Query_ServiceDesc, srv) +} + +func _Query_ClientState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryClientStateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ClientState(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_ClientState_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ClientState(ctx, req.(*QueryClientStateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_ClientStates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryClientStatesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ClientStates(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_ClientStates_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ClientStates(ctx, req.(*QueryClientStatesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_ConsensusState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryConsensusStateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ConsensusState(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_ConsensusState_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ConsensusState(ctx, req.(*QueryConsensusStateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_ConsensusStates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryConsensusStatesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ConsensusStates(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_ConsensusStates_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ConsensusStates(ctx, req.(*QueryConsensusStatesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_Relayers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryRelayersRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Relayers(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_Relayers_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Relayers(ctx, req.(*QueryRelayersRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// Query_ServiceDesc is the grpc.ServiceDesc for Query service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Query_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "tibc.core.client.v1.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "ClientState", + Handler: _Query_ClientState_Handler, + }, + { + MethodName: "ClientStates", + Handler: _Query_ClientStates_Handler, + }, + { + MethodName: "ConsensusState", + Handler: _Query_ConsensusState_Handler, + }, + { + MethodName: "ConsensusStates", + Handler: _Query_ConsensusStates_Handler, + }, + { + MethodName: "Relayers", + Handler: _Query_Relayers_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "tibc/core/client/v1/query.proto", +} diff --git a/api/tibc/core/client/v1/tx.pulsar.go b/api/tibc/core/client/v1/tx.pulsar.go new file mode 100644 index 00000000..677af6ba --- /dev/null +++ b/api/tibc/core/client/v1/tx.pulsar.go @@ -0,0 +1,4990 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package clientv1 + +import ( + _ "cosmossdk.io/api/cosmos/msg/v1" + 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" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_MsgUpdateClient protoreflect.MessageDescriptor + fd_MsgUpdateClient_chain_name protoreflect.FieldDescriptor + fd_MsgUpdateClient_header protoreflect.FieldDescriptor + fd_MsgUpdateClient_signer protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_tx_proto_init() + md_MsgUpdateClient = File_tibc_core_client_v1_tx_proto.Messages().ByName("MsgUpdateClient") + fd_MsgUpdateClient_chain_name = md_MsgUpdateClient.Fields().ByName("chain_name") + fd_MsgUpdateClient_header = md_MsgUpdateClient.Fields().ByName("header") + fd_MsgUpdateClient_signer = md_MsgUpdateClient.Fields().ByName("signer") +} + +var _ protoreflect.Message = (*fastReflection_MsgUpdateClient)(nil) + +type fastReflection_MsgUpdateClient MsgUpdateClient + +func (x *MsgUpdateClient) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgUpdateClient)(x) +} + +func (x *MsgUpdateClient) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_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_MsgUpdateClient_messageType fastReflection_MsgUpdateClient_messageType +var _ protoreflect.MessageType = fastReflection_MsgUpdateClient_messageType{} + +type fastReflection_MsgUpdateClient_messageType struct{} + +func (x fastReflection_MsgUpdateClient_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgUpdateClient)(nil) +} +func (x fastReflection_MsgUpdateClient_messageType) New() protoreflect.Message { + return new(fastReflection_MsgUpdateClient) +} +func (x fastReflection_MsgUpdateClient_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpdateClient +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgUpdateClient) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpdateClient +} + +// 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_MsgUpdateClient) Type() protoreflect.MessageType { + return _fastReflection_MsgUpdateClient_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgUpdateClient) New() protoreflect.Message { + return new(fastReflection_MsgUpdateClient) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgUpdateClient) Interface() protoreflect.ProtoMessage { + return (*MsgUpdateClient)(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_MsgUpdateClient) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ChainName != "" { + value := protoreflect.ValueOfString(x.ChainName) + if !f(fd_MsgUpdateClient_chain_name, value) { + return + } + } + if x.Header != nil { + value := protoreflect.ValueOfMessage(x.Header.ProtoReflect()) + if !f(fd_MsgUpdateClient_header, value) { + return + } + } + if x.Signer != "" { + value := protoreflect.ValueOfString(x.Signer) + if !f(fd_MsgUpdateClient_signer, 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_MsgUpdateClient) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.MsgUpdateClient.chain_name": + return x.ChainName != "" + case "tibc.core.client.v1.MsgUpdateClient.header": + return x.Header != nil + case "tibc.core.client.v1.MsgUpdateClient.signer": + return x.Signer != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpdateClient")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpdateClient 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_MsgUpdateClient) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.MsgUpdateClient.chain_name": + x.ChainName = "" + case "tibc.core.client.v1.MsgUpdateClient.header": + x.Header = nil + case "tibc.core.client.v1.MsgUpdateClient.signer": + x.Signer = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpdateClient")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpdateClient 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_MsgUpdateClient) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.MsgUpdateClient.chain_name": + value := x.ChainName + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.MsgUpdateClient.header": + value := x.Header + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.client.v1.MsgUpdateClient.signer": + value := x.Signer + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpdateClient")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpdateClient 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_MsgUpdateClient) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.MsgUpdateClient.chain_name": + x.ChainName = value.Interface().(string) + case "tibc.core.client.v1.MsgUpdateClient.header": + x.Header = value.Message().Interface().(*anypb.Any) + case "tibc.core.client.v1.MsgUpdateClient.signer": + x.Signer = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpdateClient")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpdateClient 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_MsgUpdateClient) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.MsgUpdateClient.header": + if x.Header == nil { + x.Header = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.Header.ProtoReflect()) + case "tibc.core.client.v1.MsgUpdateClient.chain_name": + panic(fmt.Errorf("field chain_name of message tibc.core.client.v1.MsgUpdateClient is not mutable")) + case "tibc.core.client.v1.MsgUpdateClient.signer": + panic(fmt.Errorf("field signer of message tibc.core.client.v1.MsgUpdateClient is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpdateClient")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpdateClient 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_MsgUpdateClient) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.MsgUpdateClient.chain_name": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.MsgUpdateClient.header": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.client.v1.MsgUpdateClient.signer": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpdateClient")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpdateClient 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_MsgUpdateClient) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.MsgUpdateClient", 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_MsgUpdateClient) 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_MsgUpdateClient) 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_MsgUpdateClient) 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_MsgUpdateClient) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgUpdateClient) + 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.ChainName) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Header != nil { + l = options.Size(x.Header) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Signer) + 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().(*MsgUpdateClient) + 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.Signer) > 0 { + i -= len(x.Signer) + copy(dAtA[i:], x.Signer) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Signer))) + i-- + dAtA[i] = 0x1a + } + if x.Header != nil { + encoded, err := options.Marshal(x.Header) + 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.ChainName) > 0 { + i -= len(x.ChainName) + copy(dAtA[i:], x.ChainName) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainName))) + 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().(*MsgUpdateClient) + 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: MsgUpdateClient: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateClient: 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 ChainName", 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.ChainName = 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 Header", 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.Header == nil { + x.Header = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Header); 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 Signer", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Signer = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + 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_MsgUpdateClientResponse protoreflect.MessageDescriptor +) + +func init() { + file_tibc_core_client_v1_tx_proto_init() + md_MsgUpdateClientResponse = File_tibc_core_client_v1_tx_proto.Messages().ByName("MsgUpdateClientResponse") +} + +var _ protoreflect.Message = (*fastReflection_MsgUpdateClientResponse)(nil) + +type fastReflection_MsgUpdateClientResponse MsgUpdateClientResponse + +func (x *MsgUpdateClientResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgUpdateClientResponse)(x) +} + +func (x *MsgUpdateClientResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_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_MsgUpdateClientResponse_messageType fastReflection_MsgUpdateClientResponse_messageType +var _ protoreflect.MessageType = fastReflection_MsgUpdateClientResponse_messageType{} + +type fastReflection_MsgUpdateClientResponse_messageType struct{} + +func (x fastReflection_MsgUpdateClientResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgUpdateClientResponse)(nil) +} +func (x fastReflection_MsgUpdateClientResponse_messageType) New() protoreflect.Message { + return new(fastReflection_MsgUpdateClientResponse) +} +func (x fastReflection_MsgUpdateClientResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpdateClientResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgUpdateClientResponse) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpdateClientResponse +} + +// 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_MsgUpdateClientResponse) Type() protoreflect.MessageType { + return _fastReflection_MsgUpdateClientResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgUpdateClientResponse) New() protoreflect.Message { + return new(fastReflection_MsgUpdateClientResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgUpdateClientResponse) Interface() protoreflect.ProtoMessage { + return (*MsgUpdateClientResponse)(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_MsgUpdateClientResponse) 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_MsgUpdateClientResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpdateClientResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpdateClientResponse 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_MsgUpdateClientResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpdateClientResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpdateClientResponse 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_MsgUpdateClientResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpdateClientResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpdateClientResponse 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_MsgUpdateClientResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpdateClientResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpdateClientResponse 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_MsgUpdateClientResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpdateClientResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpdateClientResponse 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_MsgUpdateClientResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpdateClientResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpdateClientResponse 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_MsgUpdateClientResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.MsgUpdateClientResponse", 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_MsgUpdateClientResponse) 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_MsgUpdateClientResponse) 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_MsgUpdateClientResponse) 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_MsgUpdateClientResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgUpdateClientResponse) + 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().(*MsgUpdateClientResponse) + 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().(*MsgUpdateClientResponse) + 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: MsgUpdateClientResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateClientResponse: 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_MsgCreateClient protoreflect.MessageDescriptor + fd_MsgCreateClient_title protoreflect.FieldDescriptor + fd_MsgCreateClient_description protoreflect.FieldDescriptor + fd_MsgCreateClient_chain_name protoreflect.FieldDescriptor + fd_MsgCreateClient_client_state protoreflect.FieldDescriptor + fd_MsgCreateClient_consensus_state protoreflect.FieldDescriptor + fd_MsgCreateClient_authority protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_tx_proto_init() + md_MsgCreateClient = File_tibc_core_client_v1_tx_proto.Messages().ByName("MsgCreateClient") + fd_MsgCreateClient_title = md_MsgCreateClient.Fields().ByName("title") + fd_MsgCreateClient_description = md_MsgCreateClient.Fields().ByName("description") + fd_MsgCreateClient_chain_name = md_MsgCreateClient.Fields().ByName("chain_name") + fd_MsgCreateClient_client_state = md_MsgCreateClient.Fields().ByName("client_state") + fd_MsgCreateClient_consensus_state = md_MsgCreateClient.Fields().ByName("consensus_state") + fd_MsgCreateClient_authority = md_MsgCreateClient.Fields().ByName("authority") +} + +var _ protoreflect.Message = (*fastReflection_MsgCreateClient)(nil) + +type fastReflection_MsgCreateClient MsgCreateClient + +func (x *MsgCreateClient) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgCreateClient)(x) +} + +func (x *MsgCreateClient) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_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_MsgCreateClient_messageType fastReflection_MsgCreateClient_messageType +var _ protoreflect.MessageType = fastReflection_MsgCreateClient_messageType{} + +type fastReflection_MsgCreateClient_messageType struct{} + +func (x fastReflection_MsgCreateClient_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgCreateClient)(nil) +} +func (x fastReflection_MsgCreateClient_messageType) New() protoreflect.Message { + return new(fastReflection_MsgCreateClient) +} +func (x fastReflection_MsgCreateClient_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgCreateClient +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgCreateClient) Descriptor() protoreflect.MessageDescriptor { + return md_MsgCreateClient +} + +// 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_MsgCreateClient) Type() protoreflect.MessageType { + return _fastReflection_MsgCreateClient_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgCreateClient) New() protoreflect.Message { + return new(fastReflection_MsgCreateClient) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgCreateClient) Interface() protoreflect.ProtoMessage { + return (*MsgCreateClient)(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_MsgCreateClient) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Title != "" { + value := protoreflect.ValueOfString(x.Title) + if !f(fd_MsgCreateClient_title, value) { + return + } + } + if x.Description != "" { + value := protoreflect.ValueOfString(x.Description) + if !f(fd_MsgCreateClient_description, value) { + return + } + } + if x.ChainName != "" { + value := protoreflect.ValueOfString(x.ChainName) + if !f(fd_MsgCreateClient_chain_name, value) { + return + } + } + if x.ClientState != nil { + value := protoreflect.ValueOfMessage(x.ClientState.ProtoReflect()) + if !f(fd_MsgCreateClient_client_state, value) { + return + } + } + if x.ConsensusState != nil { + value := protoreflect.ValueOfMessage(x.ConsensusState.ProtoReflect()) + if !f(fd_MsgCreateClient_consensus_state, value) { + return + } + } + if x.Authority != "" { + value := protoreflect.ValueOfString(x.Authority) + if !f(fd_MsgCreateClient_authority, 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_MsgCreateClient) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.MsgCreateClient.title": + return x.Title != "" + case "tibc.core.client.v1.MsgCreateClient.description": + return x.Description != "" + case "tibc.core.client.v1.MsgCreateClient.chain_name": + return x.ChainName != "" + case "tibc.core.client.v1.MsgCreateClient.client_state": + return x.ClientState != nil + case "tibc.core.client.v1.MsgCreateClient.consensus_state": + return x.ConsensusState != nil + case "tibc.core.client.v1.MsgCreateClient.authority": + return x.Authority != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgCreateClient")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgCreateClient 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_MsgCreateClient) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.MsgCreateClient.title": + x.Title = "" + case "tibc.core.client.v1.MsgCreateClient.description": + x.Description = "" + case "tibc.core.client.v1.MsgCreateClient.chain_name": + x.ChainName = "" + case "tibc.core.client.v1.MsgCreateClient.client_state": + x.ClientState = nil + case "tibc.core.client.v1.MsgCreateClient.consensus_state": + x.ConsensusState = nil + case "tibc.core.client.v1.MsgCreateClient.authority": + x.Authority = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgCreateClient")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgCreateClient 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_MsgCreateClient) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.MsgCreateClient.title": + value := x.Title + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.MsgCreateClient.description": + value := x.Description + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.MsgCreateClient.chain_name": + value := x.ChainName + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.MsgCreateClient.client_state": + value := x.ClientState + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.client.v1.MsgCreateClient.consensus_state": + value := x.ConsensusState + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.client.v1.MsgCreateClient.authority": + value := x.Authority + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgCreateClient")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgCreateClient 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_MsgCreateClient) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.MsgCreateClient.title": + x.Title = value.Interface().(string) + case "tibc.core.client.v1.MsgCreateClient.description": + x.Description = value.Interface().(string) + case "tibc.core.client.v1.MsgCreateClient.chain_name": + x.ChainName = value.Interface().(string) + case "tibc.core.client.v1.MsgCreateClient.client_state": + x.ClientState = value.Message().Interface().(*anypb.Any) + case "tibc.core.client.v1.MsgCreateClient.consensus_state": + x.ConsensusState = value.Message().Interface().(*anypb.Any) + case "tibc.core.client.v1.MsgCreateClient.authority": + x.Authority = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgCreateClient")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgCreateClient 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_MsgCreateClient) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.MsgCreateClient.client_state": + if x.ClientState == nil { + x.ClientState = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.ClientState.ProtoReflect()) + case "tibc.core.client.v1.MsgCreateClient.consensus_state": + if x.ConsensusState == nil { + x.ConsensusState = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.ConsensusState.ProtoReflect()) + case "tibc.core.client.v1.MsgCreateClient.title": + panic(fmt.Errorf("field title of message tibc.core.client.v1.MsgCreateClient is not mutable")) + case "tibc.core.client.v1.MsgCreateClient.description": + panic(fmt.Errorf("field description of message tibc.core.client.v1.MsgCreateClient is not mutable")) + case "tibc.core.client.v1.MsgCreateClient.chain_name": + panic(fmt.Errorf("field chain_name of message tibc.core.client.v1.MsgCreateClient is not mutable")) + case "tibc.core.client.v1.MsgCreateClient.authority": + panic(fmt.Errorf("field authority of message tibc.core.client.v1.MsgCreateClient is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgCreateClient")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgCreateClient 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_MsgCreateClient) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.MsgCreateClient.title": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.MsgCreateClient.description": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.MsgCreateClient.chain_name": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.MsgCreateClient.client_state": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.client.v1.MsgCreateClient.consensus_state": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.client.v1.MsgCreateClient.authority": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgCreateClient")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgCreateClient 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_MsgCreateClient) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.MsgCreateClient", 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_MsgCreateClient) 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_MsgCreateClient) 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_MsgCreateClient) 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_MsgCreateClient) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgCreateClient) + 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.Title) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Description) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.ChainName) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ClientState != nil { + l = options.Size(x.ClientState) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ConsensusState != nil { + l = options.Size(x.ConsensusState) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Authority) + 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().(*MsgCreateClient) + 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.Authority) > 0 { + i -= len(x.Authority) + copy(dAtA[i:], x.Authority) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority))) + i-- + dAtA[i] = 0x32 + } + if x.ConsensusState != nil { + encoded, err := options.Marshal(x.ConsensusState) + 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] = 0x2a + } + if x.ClientState != nil { + encoded, err := options.Marshal(x.ClientState) + 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] = 0x22 + } + if len(x.ChainName) > 0 { + i -= len(x.ChainName) + copy(dAtA[i:], x.ChainName) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainName))) + i-- + dAtA[i] = 0x1a + } + if len(x.Description) > 0 { + i -= len(x.Description) + copy(dAtA[i:], x.Description) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Description))) + i-- + dAtA[i] = 0x12 + } + if len(x.Title) > 0 { + i -= len(x.Title) + copy(dAtA[i:], x.Title) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Title))) + 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().(*MsgCreateClient) + 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: MsgCreateClient: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreateClient: 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 Title", 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.Title = 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 Description", 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.Description = 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 ChainName", 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.ChainName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ClientState", 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.ClientState == nil { + x.ClientState = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ClientState); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ConsensusState", 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.ConsensusState == nil { + x.ConsensusState = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ConsensusState); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", 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.Authority = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_MsgCreateClientResponse protoreflect.MessageDescriptor +) + +func init() { + file_tibc_core_client_v1_tx_proto_init() + md_MsgCreateClientResponse = File_tibc_core_client_v1_tx_proto.Messages().ByName("MsgCreateClientResponse") +} + +var _ protoreflect.Message = (*fastReflection_MsgCreateClientResponse)(nil) + +type fastReflection_MsgCreateClientResponse MsgCreateClientResponse + +func (x *MsgCreateClientResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgCreateClientResponse)(x) +} + +func (x *MsgCreateClientResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_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_MsgCreateClientResponse_messageType fastReflection_MsgCreateClientResponse_messageType +var _ protoreflect.MessageType = fastReflection_MsgCreateClientResponse_messageType{} + +type fastReflection_MsgCreateClientResponse_messageType struct{} + +func (x fastReflection_MsgCreateClientResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgCreateClientResponse)(nil) +} +func (x fastReflection_MsgCreateClientResponse_messageType) New() protoreflect.Message { + return new(fastReflection_MsgCreateClientResponse) +} +func (x fastReflection_MsgCreateClientResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgCreateClientResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgCreateClientResponse) Descriptor() protoreflect.MessageDescriptor { + return md_MsgCreateClientResponse +} + +// 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_MsgCreateClientResponse) Type() protoreflect.MessageType { + return _fastReflection_MsgCreateClientResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgCreateClientResponse) New() protoreflect.Message { + return new(fastReflection_MsgCreateClientResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgCreateClientResponse) Interface() protoreflect.ProtoMessage { + return (*MsgCreateClientResponse)(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_MsgCreateClientResponse) 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_MsgCreateClientResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgCreateClientResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgCreateClientResponse 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_MsgCreateClientResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgCreateClientResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgCreateClientResponse 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_MsgCreateClientResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgCreateClientResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgCreateClientResponse 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_MsgCreateClientResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgCreateClientResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgCreateClientResponse 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_MsgCreateClientResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgCreateClientResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgCreateClientResponse 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_MsgCreateClientResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgCreateClientResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgCreateClientResponse 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_MsgCreateClientResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.MsgCreateClientResponse", 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_MsgCreateClientResponse) 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_MsgCreateClientResponse) 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_MsgCreateClientResponse) 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_MsgCreateClientResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgCreateClientResponse) + 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().(*MsgCreateClientResponse) + 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().(*MsgCreateClientResponse) + 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: MsgCreateClientResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreateClientResponse: 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_MsgUpgradeClient protoreflect.MessageDescriptor + fd_MsgUpgradeClient_title protoreflect.FieldDescriptor + fd_MsgUpgradeClient_description protoreflect.FieldDescriptor + fd_MsgUpgradeClient_chain_name protoreflect.FieldDescriptor + fd_MsgUpgradeClient_client_state protoreflect.FieldDescriptor + fd_MsgUpgradeClient_consensus_state protoreflect.FieldDescriptor + fd_MsgUpgradeClient_authority protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_tx_proto_init() + md_MsgUpgradeClient = File_tibc_core_client_v1_tx_proto.Messages().ByName("MsgUpgradeClient") + fd_MsgUpgradeClient_title = md_MsgUpgradeClient.Fields().ByName("title") + fd_MsgUpgradeClient_description = md_MsgUpgradeClient.Fields().ByName("description") + fd_MsgUpgradeClient_chain_name = md_MsgUpgradeClient.Fields().ByName("chain_name") + fd_MsgUpgradeClient_client_state = md_MsgUpgradeClient.Fields().ByName("client_state") + fd_MsgUpgradeClient_consensus_state = md_MsgUpgradeClient.Fields().ByName("consensus_state") + fd_MsgUpgradeClient_authority = md_MsgUpgradeClient.Fields().ByName("authority") +} + +var _ protoreflect.Message = (*fastReflection_MsgUpgradeClient)(nil) + +type fastReflection_MsgUpgradeClient MsgUpgradeClient + +func (x *MsgUpgradeClient) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgUpgradeClient)(x) +} + +func (x *MsgUpgradeClient) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_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_MsgUpgradeClient_messageType fastReflection_MsgUpgradeClient_messageType +var _ protoreflect.MessageType = fastReflection_MsgUpgradeClient_messageType{} + +type fastReflection_MsgUpgradeClient_messageType struct{} + +func (x fastReflection_MsgUpgradeClient_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgUpgradeClient)(nil) +} +func (x fastReflection_MsgUpgradeClient_messageType) New() protoreflect.Message { + return new(fastReflection_MsgUpgradeClient) +} +func (x fastReflection_MsgUpgradeClient_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpgradeClient +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgUpgradeClient) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpgradeClient +} + +// 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_MsgUpgradeClient) Type() protoreflect.MessageType { + return _fastReflection_MsgUpgradeClient_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgUpgradeClient) New() protoreflect.Message { + return new(fastReflection_MsgUpgradeClient) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgUpgradeClient) Interface() protoreflect.ProtoMessage { + return (*MsgUpgradeClient)(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_MsgUpgradeClient) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Title != "" { + value := protoreflect.ValueOfString(x.Title) + if !f(fd_MsgUpgradeClient_title, value) { + return + } + } + if x.Description != "" { + value := protoreflect.ValueOfString(x.Description) + if !f(fd_MsgUpgradeClient_description, value) { + return + } + } + if x.ChainName != "" { + value := protoreflect.ValueOfString(x.ChainName) + if !f(fd_MsgUpgradeClient_chain_name, value) { + return + } + } + if x.ClientState != nil { + value := protoreflect.ValueOfMessage(x.ClientState.ProtoReflect()) + if !f(fd_MsgUpgradeClient_client_state, value) { + return + } + } + if x.ConsensusState != nil { + value := protoreflect.ValueOfMessage(x.ConsensusState.ProtoReflect()) + if !f(fd_MsgUpgradeClient_consensus_state, value) { + return + } + } + if x.Authority != "" { + value := protoreflect.ValueOfString(x.Authority) + if !f(fd_MsgUpgradeClient_authority, 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_MsgUpgradeClient) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.MsgUpgradeClient.title": + return x.Title != "" + case "tibc.core.client.v1.MsgUpgradeClient.description": + return x.Description != "" + case "tibc.core.client.v1.MsgUpgradeClient.chain_name": + return x.ChainName != "" + case "tibc.core.client.v1.MsgUpgradeClient.client_state": + return x.ClientState != nil + case "tibc.core.client.v1.MsgUpgradeClient.consensus_state": + return x.ConsensusState != nil + case "tibc.core.client.v1.MsgUpgradeClient.authority": + return x.Authority != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpgradeClient")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpgradeClient 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_MsgUpgradeClient) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.MsgUpgradeClient.title": + x.Title = "" + case "tibc.core.client.v1.MsgUpgradeClient.description": + x.Description = "" + case "tibc.core.client.v1.MsgUpgradeClient.chain_name": + x.ChainName = "" + case "tibc.core.client.v1.MsgUpgradeClient.client_state": + x.ClientState = nil + case "tibc.core.client.v1.MsgUpgradeClient.consensus_state": + x.ConsensusState = nil + case "tibc.core.client.v1.MsgUpgradeClient.authority": + x.Authority = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpgradeClient")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpgradeClient 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_MsgUpgradeClient) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.MsgUpgradeClient.title": + value := x.Title + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.MsgUpgradeClient.description": + value := x.Description + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.MsgUpgradeClient.chain_name": + value := x.ChainName + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.MsgUpgradeClient.client_state": + value := x.ClientState + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.client.v1.MsgUpgradeClient.consensus_state": + value := x.ConsensusState + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.client.v1.MsgUpgradeClient.authority": + value := x.Authority + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpgradeClient")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpgradeClient 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_MsgUpgradeClient) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.MsgUpgradeClient.title": + x.Title = value.Interface().(string) + case "tibc.core.client.v1.MsgUpgradeClient.description": + x.Description = value.Interface().(string) + case "tibc.core.client.v1.MsgUpgradeClient.chain_name": + x.ChainName = value.Interface().(string) + case "tibc.core.client.v1.MsgUpgradeClient.client_state": + x.ClientState = value.Message().Interface().(*anypb.Any) + case "tibc.core.client.v1.MsgUpgradeClient.consensus_state": + x.ConsensusState = value.Message().Interface().(*anypb.Any) + case "tibc.core.client.v1.MsgUpgradeClient.authority": + x.Authority = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpgradeClient")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpgradeClient 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_MsgUpgradeClient) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.MsgUpgradeClient.client_state": + if x.ClientState == nil { + x.ClientState = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.ClientState.ProtoReflect()) + case "tibc.core.client.v1.MsgUpgradeClient.consensus_state": + if x.ConsensusState == nil { + x.ConsensusState = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.ConsensusState.ProtoReflect()) + case "tibc.core.client.v1.MsgUpgradeClient.title": + panic(fmt.Errorf("field title of message tibc.core.client.v1.MsgUpgradeClient is not mutable")) + case "tibc.core.client.v1.MsgUpgradeClient.description": + panic(fmt.Errorf("field description of message tibc.core.client.v1.MsgUpgradeClient is not mutable")) + case "tibc.core.client.v1.MsgUpgradeClient.chain_name": + panic(fmt.Errorf("field chain_name of message tibc.core.client.v1.MsgUpgradeClient is not mutable")) + case "tibc.core.client.v1.MsgUpgradeClient.authority": + panic(fmt.Errorf("field authority of message tibc.core.client.v1.MsgUpgradeClient is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpgradeClient")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpgradeClient 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_MsgUpgradeClient) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.MsgUpgradeClient.title": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.MsgUpgradeClient.description": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.MsgUpgradeClient.chain_name": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.MsgUpgradeClient.client_state": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.client.v1.MsgUpgradeClient.consensus_state": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.client.v1.MsgUpgradeClient.authority": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpgradeClient")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpgradeClient 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_MsgUpgradeClient) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.MsgUpgradeClient", 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_MsgUpgradeClient) 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_MsgUpgradeClient) 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_MsgUpgradeClient) 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_MsgUpgradeClient) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgUpgradeClient) + 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.Title) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Description) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.ChainName) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ClientState != nil { + l = options.Size(x.ClientState) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ConsensusState != nil { + l = options.Size(x.ConsensusState) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Authority) + 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().(*MsgUpgradeClient) + 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.Authority) > 0 { + i -= len(x.Authority) + copy(dAtA[i:], x.Authority) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority))) + i-- + dAtA[i] = 0x32 + } + if x.ConsensusState != nil { + encoded, err := options.Marshal(x.ConsensusState) + 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] = 0x2a + } + if x.ClientState != nil { + encoded, err := options.Marshal(x.ClientState) + 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] = 0x22 + } + if len(x.ChainName) > 0 { + i -= len(x.ChainName) + copy(dAtA[i:], x.ChainName) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainName))) + i-- + dAtA[i] = 0x1a + } + if len(x.Description) > 0 { + i -= len(x.Description) + copy(dAtA[i:], x.Description) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Description))) + i-- + dAtA[i] = 0x12 + } + if len(x.Title) > 0 { + i -= len(x.Title) + copy(dAtA[i:], x.Title) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Title))) + 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().(*MsgUpgradeClient) + 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: MsgUpgradeClient: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpgradeClient: 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 Title", 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.Title = 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 Description", 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.Description = 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 ChainName", 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.ChainName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ClientState", 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.ClientState == nil { + x.ClientState = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ClientState); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ConsensusState", 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.ConsensusState == nil { + x.ConsensusState = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ConsensusState); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", 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.Authority = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_MsgUpgradeClientResponse protoreflect.MessageDescriptor +) + +func init() { + file_tibc_core_client_v1_tx_proto_init() + md_MsgUpgradeClientResponse = File_tibc_core_client_v1_tx_proto.Messages().ByName("MsgUpgradeClientResponse") +} + +var _ protoreflect.Message = (*fastReflection_MsgUpgradeClientResponse)(nil) + +type fastReflection_MsgUpgradeClientResponse MsgUpgradeClientResponse + +func (x *MsgUpgradeClientResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgUpgradeClientResponse)(x) +} + +func (x *MsgUpgradeClientResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_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_MsgUpgradeClientResponse_messageType fastReflection_MsgUpgradeClientResponse_messageType +var _ protoreflect.MessageType = fastReflection_MsgUpgradeClientResponse_messageType{} + +type fastReflection_MsgUpgradeClientResponse_messageType struct{} + +func (x fastReflection_MsgUpgradeClientResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgUpgradeClientResponse)(nil) +} +func (x fastReflection_MsgUpgradeClientResponse_messageType) New() protoreflect.Message { + return new(fastReflection_MsgUpgradeClientResponse) +} +func (x fastReflection_MsgUpgradeClientResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpgradeClientResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgUpgradeClientResponse) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpgradeClientResponse +} + +// 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_MsgUpgradeClientResponse) Type() protoreflect.MessageType { + return _fastReflection_MsgUpgradeClientResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgUpgradeClientResponse) New() protoreflect.Message { + return new(fastReflection_MsgUpgradeClientResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgUpgradeClientResponse) Interface() protoreflect.ProtoMessage { + return (*MsgUpgradeClientResponse)(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_MsgUpgradeClientResponse) 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_MsgUpgradeClientResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpgradeClientResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpgradeClientResponse 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_MsgUpgradeClientResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpgradeClientResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpgradeClientResponse 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_MsgUpgradeClientResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpgradeClientResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpgradeClientResponse 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_MsgUpgradeClientResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpgradeClientResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpgradeClientResponse 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_MsgUpgradeClientResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpgradeClientResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpgradeClientResponse 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_MsgUpgradeClientResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgUpgradeClientResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgUpgradeClientResponse 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_MsgUpgradeClientResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.MsgUpgradeClientResponse", 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_MsgUpgradeClientResponse) 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_MsgUpgradeClientResponse) 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_MsgUpgradeClientResponse) 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_MsgUpgradeClientResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgUpgradeClientResponse) + 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().(*MsgUpgradeClientResponse) + 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().(*MsgUpgradeClientResponse) + 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: MsgUpgradeClientResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpgradeClientResponse: 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 = (*_MsgRegisterRelayer_4_list)(nil) + +type _MsgRegisterRelayer_4_list struct { + list *[]string +} + +func (x *_MsgRegisterRelayer_4_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_MsgRegisterRelayer_4_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfString((*x.list)[i]) +} + +func (x *_MsgRegisterRelayer_4_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_MsgRegisterRelayer_4_list) Append(value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_MsgRegisterRelayer_4_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message MsgRegisterRelayer at list field Relayers as it is not of Message kind")) +} + +func (x *_MsgRegisterRelayer_4_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_MsgRegisterRelayer_4_list) NewElement() protoreflect.Value { + v := "" + return protoreflect.ValueOfString(v) +} + +func (x *_MsgRegisterRelayer_4_list) IsValid() bool { + return x.list != nil +} + +var ( + md_MsgRegisterRelayer protoreflect.MessageDescriptor + fd_MsgRegisterRelayer_title protoreflect.FieldDescriptor + fd_MsgRegisterRelayer_description protoreflect.FieldDescriptor + fd_MsgRegisterRelayer_chain_name protoreflect.FieldDescriptor + fd_MsgRegisterRelayer_relayers protoreflect.FieldDescriptor + fd_MsgRegisterRelayer_authority protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_client_v1_tx_proto_init() + md_MsgRegisterRelayer = File_tibc_core_client_v1_tx_proto.Messages().ByName("MsgRegisterRelayer") + fd_MsgRegisterRelayer_title = md_MsgRegisterRelayer.Fields().ByName("title") + fd_MsgRegisterRelayer_description = md_MsgRegisterRelayer.Fields().ByName("description") + fd_MsgRegisterRelayer_chain_name = md_MsgRegisterRelayer.Fields().ByName("chain_name") + fd_MsgRegisterRelayer_relayers = md_MsgRegisterRelayer.Fields().ByName("relayers") + fd_MsgRegisterRelayer_authority = md_MsgRegisterRelayer.Fields().ByName("authority") +} + +var _ protoreflect.Message = (*fastReflection_MsgRegisterRelayer)(nil) + +type fastReflection_MsgRegisterRelayer MsgRegisterRelayer + +func (x *MsgRegisterRelayer) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgRegisterRelayer)(x) +} + +func (x *MsgRegisterRelayer) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_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_MsgRegisterRelayer_messageType fastReflection_MsgRegisterRelayer_messageType +var _ protoreflect.MessageType = fastReflection_MsgRegisterRelayer_messageType{} + +type fastReflection_MsgRegisterRelayer_messageType struct{} + +func (x fastReflection_MsgRegisterRelayer_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgRegisterRelayer)(nil) +} +func (x fastReflection_MsgRegisterRelayer_messageType) New() protoreflect.Message { + return new(fastReflection_MsgRegisterRelayer) +} +func (x fastReflection_MsgRegisterRelayer_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgRegisterRelayer +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgRegisterRelayer) Descriptor() protoreflect.MessageDescriptor { + return md_MsgRegisterRelayer +} + +// 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_MsgRegisterRelayer) Type() protoreflect.MessageType { + return _fastReflection_MsgRegisterRelayer_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgRegisterRelayer) New() protoreflect.Message { + return new(fastReflection_MsgRegisterRelayer) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgRegisterRelayer) Interface() protoreflect.ProtoMessage { + return (*MsgRegisterRelayer)(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_MsgRegisterRelayer) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Title != "" { + value := protoreflect.ValueOfString(x.Title) + if !f(fd_MsgRegisterRelayer_title, value) { + return + } + } + if x.Description != "" { + value := protoreflect.ValueOfString(x.Description) + if !f(fd_MsgRegisterRelayer_description, value) { + return + } + } + if x.ChainName != "" { + value := protoreflect.ValueOfString(x.ChainName) + if !f(fd_MsgRegisterRelayer_chain_name, value) { + return + } + } + if len(x.Relayers) != 0 { + value := protoreflect.ValueOfList(&_MsgRegisterRelayer_4_list{list: &x.Relayers}) + if !f(fd_MsgRegisterRelayer_relayers, value) { + return + } + } + if x.Authority != "" { + value := protoreflect.ValueOfString(x.Authority) + if !f(fd_MsgRegisterRelayer_authority, 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_MsgRegisterRelayer) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.client.v1.MsgRegisterRelayer.title": + return x.Title != "" + case "tibc.core.client.v1.MsgRegisterRelayer.description": + return x.Description != "" + case "tibc.core.client.v1.MsgRegisterRelayer.chain_name": + return x.ChainName != "" + case "tibc.core.client.v1.MsgRegisterRelayer.relayers": + return len(x.Relayers) != 0 + case "tibc.core.client.v1.MsgRegisterRelayer.authority": + return x.Authority != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgRegisterRelayer")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgRegisterRelayer 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_MsgRegisterRelayer) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.client.v1.MsgRegisterRelayer.title": + x.Title = "" + case "tibc.core.client.v1.MsgRegisterRelayer.description": + x.Description = "" + case "tibc.core.client.v1.MsgRegisterRelayer.chain_name": + x.ChainName = "" + case "tibc.core.client.v1.MsgRegisterRelayer.relayers": + x.Relayers = nil + case "tibc.core.client.v1.MsgRegisterRelayer.authority": + x.Authority = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgRegisterRelayer")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgRegisterRelayer 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_MsgRegisterRelayer) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.client.v1.MsgRegisterRelayer.title": + value := x.Title + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.MsgRegisterRelayer.description": + value := x.Description + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.MsgRegisterRelayer.chain_name": + value := x.ChainName + return protoreflect.ValueOfString(value) + case "tibc.core.client.v1.MsgRegisterRelayer.relayers": + if len(x.Relayers) == 0 { + return protoreflect.ValueOfList(&_MsgRegisterRelayer_4_list{}) + } + listValue := &_MsgRegisterRelayer_4_list{list: &x.Relayers} + return protoreflect.ValueOfList(listValue) + case "tibc.core.client.v1.MsgRegisterRelayer.authority": + value := x.Authority + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgRegisterRelayer")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgRegisterRelayer 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_MsgRegisterRelayer) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.client.v1.MsgRegisterRelayer.title": + x.Title = value.Interface().(string) + case "tibc.core.client.v1.MsgRegisterRelayer.description": + x.Description = value.Interface().(string) + case "tibc.core.client.v1.MsgRegisterRelayer.chain_name": + x.ChainName = value.Interface().(string) + case "tibc.core.client.v1.MsgRegisterRelayer.relayers": + lv := value.List() + clv := lv.(*_MsgRegisterRelayer_4_list) + x.Relayers = *clv.list + case "tibc.core.client.v1.MsgRegisterRelayer.authority": + x.Authority = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgRegisterRelayer")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgRegisterRelayer 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_MsgRegisterRelayer) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.MsgRegisterRelayer.relayers": + if x.Relayers == nil { + x.Relayers = []string{} + } + value := &_MsgRegisterRelayer_4_list{list: &x.Relayers} + return protoreflect.ValueOfList(value) + case "tibc.core.client.v1.MsgRegisterRelayer.title": + panic(fmt.Errorf("field title of message tibc.core.client.v1.MsgRegisterRelayer is not mutable")) + case "tibc.core.client.v1.MsgRegisterRelayer.description": + panic(fmt.Errorf("field description of message tibc.core.client.v1.MsgRegisterRelayer is not mutable")) + case "tibc.core.client.v1.MsgRegisterRelayer.chain_name": + panic(fmt.Errorf("field chain_name of message tibc.core.client.v1.MsgRegisterRelayer is not mutable")) + case "tibc.core.client.v1.MsgRegisterRelayer.authority": + panic(fmt.Errorf("field authority of message tibc.core.client.v1.MsgRegisterRelayer is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgRegisterRelayer")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgRegisterRelayer 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_MsgRegisterRelayer) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.client.v1.MsgRegisterRelayer.title": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.MsgRegisterRelayer.description": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.MsgRegisterRelayer.chain_name": + return protoreflect.ValueOfString("") + case "tibc.core.client.v1.MsgRegisterRelayer.relayers": + list := []string{} + return protoreflect.ValueOfList(&_MsgRegisterRelayer_4_list{list: &list}) + case "tibc.core.client.v1.MsgRegisterRelayer.authority": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgRegisterRelayer")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgRegisterRelayer 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_MsgRegisterRelayer) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.MsgRegisterRelayer", 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_MsgRegisterRelayer) 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_MsgRegisterRelayer) 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_MsgRegisterRelayer) 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_MsgRegisterRelayer) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgRegisterRelayer) + 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.Title) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Description) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.ChainName) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.Relayers) > 0 { + for _, s := range x.Relayers { + l = len(s) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + l = len(x.Authority) + 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().(*MsgRegisterRelayer) + 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.Authority) > 0 { + i -= len(x.Authority) + copy(dAtA[i:], x.Authority) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority))) + i-- + dAtA[i] = 0x2a + } + if len(x.Relayers) > 0 { + for iNdEx := len(x.Relayers) - 1; iNdEx >= 0; iNdEx-- { + i -= len(x.Relayers[iNdEx]) + copy(dAtA[i:], x.Relayers[iNdEx]) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Relayers[iNdEx]))) + i-- + dAtA[i] = 0x22 + } + } + if len(x.ChainName) > 0 { + i -= len(x.ChainName) + copy(dAtA[i:], x.ChainName) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainName))) + i-- + dAtA[i] = 0x1a + } + if len(x.Description) > 0 { + i -= len(x.Description) + copy(dAtA[i:], x.Description) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Description))) + i-- + dAtA[i] = 0x12 + } + if len(x.Title) > 0 { + i -= len(x.Title) + copy(dAtA[i:], x.Title) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Title))) + 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().(*MsgRegisterRelayer) + 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: MsgRegisterRelayer: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterRelayer: 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 Title", 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.Title = 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 Description", 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.Description = 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 ChainName", 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.ChainName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Relayers", 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.Relayers = append(x.Relayers, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", 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.Authority = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_MsgRegisterRelayerResponse protoreflect.MessageDescriptor +) + +func init() { + file_tibc_core_client_v1_tx_proto_init() + md_MsgRegisterRelayerResponse = File_tibc_core_client_v1_tx_proto.Messages().ByName("MsgRegisterRelayerResponse") +} + +var _ protoreflect.Message = (*fastReflection_MsgRegisterRelayerResponse)(nil) + +type fastReflection_MsgRegisterRelayerResponse MsgRegisterRelayerResponse + +func (x *MsgRegisterRelayerResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgRegisterRelayerResponse)(x) +} + +func (x *MsgRegisterRelayerResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_client_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_MsgRegisterRelayerResponse_messageType fastReflection_MsgRegisterRelayerResponse_messageType +var _ protoreflect.MessageType = fastReflection_MsgRegisterRelayerResponse_messageType{} + +type fastReflection_MsgRegisterRelayerResponse_messageType struct{} + +func (x fastReflection_MsgRegisterRelayerResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgRegisterRelayerResponse)(nil) +} +func (x fastReflection_MsgRegisterRelayerResponse_messageType) New() protoreflect.Message { + return new(fastReflection_MsgRegisterRelayerResponse) +} +func (x fastReflection_MsgRegisterRelayerResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgRegisterRelayerResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgRegisterRelayerResponse) Descriptor() protoreflect.MessageDescriptor { + return md_MsgRegisterRelayerResponse +} + +// 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_MsgRegisterRelayerResponse) Type() protoreflect.MessageType { + return _fastReflection_MsgRegisterRelayerResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgRegisterRelayerResponse) New() protoreflect.Message { + return new(fastReflection_MsgRegisterRelayerResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgRegisterRelayerResponse) Interface() protoreflect.ProtoMessage { + return (*MsgRegisterRelayerResponse)(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_MsgRegisterRelayerResponse) 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_MsgRegisterRelayerResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgRegisterRelayerResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgRegisterRelayerResponse 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_MsgRegisterRelayerResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgRegisterRelayerResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgRegisterRelayerResponse 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_MsgRegisterRelayerResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgRegisterRelayerResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgRegisterRelayerResponse 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_MsgRegisterRelayerResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgRegisterRelayerResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgRegisterRelayerResponse 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_MsgRegisterRelayerResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgRegisterRelayerResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgRegisterRelayerResponse 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_MsgRegisterRelayerResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.client.v1.MsgRegisterRelayerResponse")) + } + panic(fmt.Errorf("message tibc.core.client.v1.MsgRegisterRelayerResponse 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_MsgRegisterRelayerResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.client.v1.MsgRegisterRelayerResponse", 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_MsgRegisterRelayerResponse) 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_MsgRegisterRelayerResponse) 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_MsgRegisterRelayerResponse) 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_MsgRegisterRelayerResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgRegisterRelayerResponse) + 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().(*MsgRegisterRelayerResponse) + 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().(*MsgRegisterRelayerResponse) + 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: MsgRegisterRelayerResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterRelayerResponse: 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, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: tibc/core/client/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) +) + +// MsgUpdateClient defines an sdk.Msg to update a TIBC client state using +// the given header. +type MsgUpdateClient struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // client unique identifier + ChainName string `protobuf:"bytes,1,opt,name=chain_name,json=chainName,proto3" json:"chain_name,omitempty"` + // header to update the light client + Header *anypb.Any `protobuf:"bytes,2,opt,name=header,proto3" json:"header,omitempty"` + // signer address + Signer string `protobuf:"bytes,3,opt,name=signer,proto3" json:"signer,omitempty"` +} + +func (x *MsgUpdateClient) Reset() { + *x = MsgUpdateClient{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_tx_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgUpdateClient) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgUpdateClient) ProtoMessage() {} + +// Deprecated: Use MsgUpdateClient.ProtoReflect.Descriptor instead. +func (*MsgUpdateClient) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_tx_proto_rawDescGZIP(), []int{0} +} + +func (x *MsgUpdateClient) GetChainName() string { + if x != nil { + return x.ChainName + } + return "" +} + +func (x *MsgUpdateClient) GetHeader() *anypb.Any { + if x != nil { + return x.Header + } + return nil +} + +func (x *MsgUpdateClient) GetSigner() string { + if x != nil { + return x.Signer + } + return "" +} + +// MsgUpdateClientResponse defines the Msg/UpdateClient response type. +type MsgUpdateClientResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *MsgUpdateClientResponse) Reset() { + *x = MsgUpdateClientResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_tx_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgUpdateClientResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgUpdateClientResponse) ProtoMessage() {} + +// Deprecated: Use MsgUpdateClientResponse.ProtoReflect.Descriptor instead. +func (*MsgUpdateClientResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_tx_proto_rawDescGZIP(), []int{1} +} + +// MsgCreateClient defines a overnance proposal to create an TIBC client +type MsgCreateClient struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // the title of the update proposal + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` + // the description of the proposal + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` + // the client identifier for the client to be updated if the proposal passes + ChainName string `protobuf:"bytes,3,opt,name=chain_name,json=chainName,proto3" json:"chain_name,omitempty"` + // light client state + ClientState *anypb.Any `protobuf:"bytes,4,opt,name=client_state,json=clientState,proto3" json:"client_state,omitempty"` + // consensus state associated with the client that corresponds to a given + // height. + ConsensusState *anypb.Any `protobuf:"bytes,5,opt,name=consensus_state,json=consensusState,proto3" json:"consensus_state,omitempty"` + // authority is the address that controls the module (defaults to x/gov unless + // overwritten). + Authority string `protobuf:"bytes,6,opt,name=authority,proto3" json:"authority,omitempty"` +} + +func (x *MsgCreateClient) Reset() { + *x = MsgCreateClient{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_tx_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgCreateClient) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgCreateClient) ProtoMessage() {} + +// Deprecated: Use MsgCreateClient.ProtoReflect.Descriptor instead. +func (*MsgCreateClient) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_tx_proto_rawDescGZIP(), []int{2} +} + +func (x *MsgCreateClient) GetTitle() string { + if x != nil { + return x.Title + } + return "" +} + +func (x *MsgCreateClient) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +func (x *MsgCreateClient) GetChainName() string { + if x != nil { + return x.ChainName + } + return "" +} + +func (x *MsgCreateClient) GetClientState() *anypb.Any { + if x != nil { + return x.ClientState + } + return nil +} + +func (x *MsgCreateClient) GetConsensusState() *anypb.Any { + if x != nil { + return x.ConsensusState + } + return nil +} + +func (x *MsgCreateClient) GetAuthority() string { + if x != nil { + return x.Authority + } + return "" +} + +// MsgCreateClientResponse defines the Msg/UpdateClient response type. +type MsgCreateClientResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *MsgCreateClientResponse) Reset() { + *x = MsgCreateClientResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_tx_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgCreateClientResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgCreateClientResponse) ProtoMessage() {} + +// Deprecated: Use MsgCreateClientResponse.ProtoReflect.Descriptor instead. +func (*MsgCreateClientResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_tx_proto_rawDescGZIP(), []int{3} +} + +// MsgUpgradeClient defines a overnance proposal to overide an TIBC client +// state +type MsgUpgradeClient struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // the title of the update proposal + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` + // the description of the proposal + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` + // the client identifier for the client to be updated if the proposal passes + ChainName string `protobuf:"bytes,3,opt,name=chain_name,json=chainName,proto3" json:"chain_name,omitempty"` + // client state + ClientState *anypb.Any `protobuf:"bytes,4,opt,name=client_state,json=clientState,proto3" json:"client_state,omitempty"` + // consensus state + ConsensusState *anypb.Any `protobuf:"bytes,5,opt,name=consensus_state,json=consensusState,proto3" json:"consensus_state,omitempty"` + // authority is the address that controls the module (defaults to x/gov unless + // overwritten). + Authority string `protobuf:"bytes,6,opt,name=authority,proto3" json:"authority,omitempty"` +} + +func (x *MsgUpgradeClient) Reset() { + *x = MsgUpgradeClient{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_tx_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgUpgradeClient) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgUpgradeClient) ProtoMessage() {} + +// Deprecated: Use MsgUpgradeClient.ProtoReflect.Descriptor instead. +func (*MsgUpgradeClient) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_tx_proto_rawDescGZIP(), []int{4} +} + +func (x *MsgUpgradeClient) GetTitle() string { + if x != nil { + return x.Title + } + return "" +} + +func (x *MsgUpgradeClient) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +func (x *MsgUpgradeClient) GetChainName() string { + if x != nil { + return x.ChainName + } + return "" +} + +func (x *MsgUpgradeClient) GetClientState() *anypb.Any { + if x != nil { + return x.ClientState + } + return nil +} + +func (x *MsgUpgradeClient) GetConsensusState() *anypb.Any { + if x != nil { + return x.ConsensusState + } + return nil +} + +func (x *MsgUpgradeClient) GetAuthority() string { + if x != nil { + return x.Authority + } + return "" +} + +// MsgCreateClientResponse defines the Msg/UpdateClient response type. +type MsgUpgradeClientResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *MsgUpgradeClientResponse) Reset() { + *x = MsgUpgradeClientResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_tx_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgUpgradeClientResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgUpgradeClientResponse) ProtoMessage() {} + +// Deprecated: Use MsgUpgradeClientResponse.ProtoReflect.Descriptor instead. +func (*MsgUpgradeClientResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_tx_proto_rawDescGZIP(), []int{5} +} + +// MsgRegisterRelayer defines a overnance proposal to register some +// relayers for updating a client state. +type MsgRegisterRelayer struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // the title of the update proposal + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` + // the description of the proposal + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` + // the client identifier for the client to be updated if the proposal passes + ChainName string `protobuf:"bytes,3,opt,name=chain_name,json=chainName,proto3" json:"chain_name,omitempty"` + // relayer address list + Relayers []string `protobuf:"bytes,4,rep,name=relayers,proto3" json:"relayers,omitempty"` + // authority is the address that controls the module (defaults to x/gov unless + // overwritten). + Authority string `protobuf:"bytes,5,opt,name=authority,proto3" json:"authority,omitempty"` +} + +func (x *MsgRegisterRelayer) Reset() { + *x = MsgRegisterRelayer{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_tx_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgRegisterRelayer) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgRegisterRelayer) ProtoMessage() {} + +// Deprecated: Use MsgRegisterRelayer.ProtoReflect.Descriptor instead. +func (*MsgRegisterRelayer) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_tx_proto_rawDescGZIP(), []int{6} +} + +func (x *MsgRegisterRelayer) GetTitle() string { + if x != nil { + return x.Title + } + return "" +} + +func (x *MsgRegisterRelayer) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +func (x *MsgRegisterRelayer) GetChainName() string { + if x != nil { + return x.ChainName + } + return "" +} + +func (x *MsgRegisterRelayer) GetRelayers() []string { + if x != nil { + return x.Relayers + } + return nil +} + +func (x *MsgRegisterRelayer) GetAuthority() string { + if x != nil { + return x.Authority + } + return "" +} + +// MsgRegisterRelayerResponse defines the Msg/UpdateClient response type. +type MsgRegisterRelayerResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *MsgRegisterRelayerResponse) Reset() { + *x = MsgRegisterRelayerResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_client_v1_tx_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgRegisterRelayerResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgRegisterRelayerResponse) ProtoMessage() {} + +// Deprecated: Use MsgRegisterRelayerResponse.ProtoReflect.Descriptor instead. +func (*MsgRegisterRelayerResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_client_v1_tx_proto_rawDescGZIP(), []int{7} +} + +var File_tibc_core_client_v1_tx_proto protoreflect.FileDescriptor + +var file_tibc_core_client_v1_tx_proto_rawDesc = []byte{ + 0x0a, 0x1c, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x74, 0x78, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x13, + 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x2e, 0x76, 0x31, 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, 0x17, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6d, 0x73, 0x67, + 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x73, 0x67, 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, 0x22, 0x8b, 0x01, 0x0a, 0x0f, 0x4d, 0x73, 0x67, + 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x1d, 0x0a, 0x0a, + 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x2c, 0x0a, 0x06, 0x68, + 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 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, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x69, 0x67, + 0x6e, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x69, 0x67, 0x6e, 0x65, + 0x72, 0x3a, 0x13, 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x82, 0xe7, 0xb0, 0x2a, 0x06, + 0x73, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x22, 0x19, 0x0a, 0x17, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0xac, 0x02, 0x0a, 0x0f, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x43, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x64, + 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, + 0x0a, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x09, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x37, 0x0a, 0x0c, + 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, + 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, 0x0b, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x3d, 0x0a, 0x0f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, + 0x75, 0x73, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 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, 0x0e, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, + 0x74, 0x61, 0x74, 0x65, 0x12, 0x36, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, + 0x79, 0x18, 0x06, 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, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x3a, 0x12, 0x88, 0xa0, + 0x1f, 0x00, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, + 0x22, 0x19, 0x0a, 0x17, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x43, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xad, 0x02, 0x0a, 0x10, + 0x4d, 0x73, 0x67, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x12, 0x14, 0x0a, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x69, + 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x68, + 0x61, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x37, 0x0a, 0x0c, 0x63, 0x6c, 0x69, 0x65, 0x6e, + 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 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, 0x0b, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, + 0x12, 0x3d, 0x0a, 0x0f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x5f, 0x73, 0x74, + 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 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, + 0x0e, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, + 0x36, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x06, 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, 0x61, 0x75, + 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x3a, 0x12, 0x88, 0xa0, 0x1f, 0x00, 0x82, 0xe7, 0xb0, + 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x1a, 0x0a, 0x18, 0x4d, + 0x73, 0x67, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xd3, 0x01, 0x0a, 0x12, 0x4d, 0x73, 0x67, 0x52, + 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x12, 0x14, + 0x0a, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, + 0x69, 0x74, 0x6c, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x68, 0x61, 0x69, + 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, + 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x72, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, + 0x73, 0x12, 0x36, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x05, + 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, + 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x3a, 0x12, 0x88, 0xa0, 0x1f, 0x00, 0x82, + 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x1c, 0x0a, + 0x1a, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x6c, 0x61, + 0x79, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0xa1, 0x03, 0x0a, 0x03, + 0x4d, 0x73, 0x67, 0x12, 0x62, 0x0a, 0x0c, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x43, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x12, 0x24, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x1a, 0x2c, 0x2e, 0x74, 0x69, 0x62, 0x63, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, + 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x62, 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x24, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, + 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x1a, 0x2c, 0x2e, + 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x65, 0x0a, 0x0d, 0x55, + 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x25, 0x2e, 0x74, + 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, + 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x43, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x1a, 0x2d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x67, + 0x72, 0x61, 0x64, 0x65, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x6b, 0x0a, 0x0f, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, + 0x6c, 0x61, 0x79, 0x65, 0x72, 0x12, 0x27, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x52, + 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x1a, 0x2f, + 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, + 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, + 0x52, 0x65, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, + 0xd0, 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x42, 0x07, 0x54, 0x78, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, + 0x63, 0x2d, 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, + 0x72, 0x65, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x3b, 0x63, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x54, 0x43, 0x43, 0xaa, 0x02, 0x13, 0x54, 0x69, + 0x62, 0x63, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x56, + 0x31, 0xca, 0x02, 0x13, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x43, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x1f, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x43, + 0x6f, 0x72, 0x65, 0x5c, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, + 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x16, 0x54, 0x69, 0x62, 0x63, + 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x3a, 0x3a, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x3a, 0x3a, + 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_core_client_v1_tx_proto_rawDescOnce sync.Once + file_tibc_core_client_v1_tx_proto_rawDescData = file_tibc_core_client_v1_tx_proto_rawDesc +) + +func file_tibc_core_client_v1_tx_proto_rawDescGZIP() []byte { + file_tibc_core_client_v1_tx_proto_rawDescOnce.Do(func() { + file_tibc_core_client_v1_tx_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_core_client_v1_tx_proto_rawDescData) + }) + return file_tibc_core_client_v1_tx_proto_rawDescData +} + +var file_tibc_core_client_v1_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 8) +var file_tibc_core_client_v1_tx_proto_goTypes = []interface{}{ + (*MsgUpdateClient)(nil), // 0: tibc.core.client.v1.MsgUpdateClient + (*MsgUpdateClientResponse)(nil), // 1: tibc.core.client.v1.MsgUpdateClientResponse + (*MsgCreateClient)(nil), // 2: tibc.core.client.v1.MsgCreateClient + (*MsgCreateClientResponse)(nil), // 3: tibc.core.client.v1.MsgCreateClientResponse + (*MsgUpgradeClient)(nil), // 4: tibc.core.client.v1.MsgUpgradeClient + (*MsgUpgradeClientResponse)(nil), // 5: tibc.core.client.v1.MsgUpgradeClientResponse + (*MsgRegisterRelayer)(nil), // 6: tibc.core.client.v1.MsgRegisterRelayer + (*MsgRegisterRelayerResponse)(nil), // 7: tibc.core.client.v1.MsgRegisterRelayerResponse + (*anypb.Any)(nil), // 8: google.protobuf.Any +} +var file_tibc_core_client_v1_tx_proto_depIdxs = []int32{ + 8, // 0: tibc.core.client.v1.MsgUpdateClient.header:type_name -> google.protobuf.Any + 8, // 1: tibc.core.client.v1.MsgCreateClient.client_state:type_name -> google.protobuf.Any + 8, // 2: tibc.core.client.v1.MsgCreateClient.consensus_state:type_name -> google.protobuf.Any + 8, // 3: tibc.core.client.v1.MsgUpgradeClient.client_state:type_name -> google.protobuf.Any + 8, // 4: tibc.core.client.v1.MsgUpgradeClient.consensus_state:type_name -> google.protobuf.Any + 2, // 5: tibc.core.client.v1.Msg.CreateClient:input_type -> tibc.core.client.v1.MsgCreateClient + 0, // 6: tibc.core.client.v1.Msg.UpdateClient:input_type -> tibc.core.client.v1.MsgUpdateClient + 4, // 7: tibc.core.client.v1.Msg.UpgradeClient:input_type -> tibc.core.client.v1.MsgUpgradeClient + 6, // 8: tibc.core.client.v1.Msg.RegisterRelayer:input_type -> tibc.core.client.v1.MsgRegisterRelayer + 3, // 9: tibc.core.client.v1.Msg.CreateClient:output_type -> tibc.core.client.v1.MsgCreateClientResponse + 1, // 10: tibc.core.client.v1.Msg.UpdateClient:output_type -> tibc.core.client.v1.MsgUpdateClientResponse + 5, // 11: tibc.core.client.v1.Msg.UpgradeClient:output_type -> tibc.core.client.v1.MsgUpgradeClientResponse + 7, // 12: tibc.core.client.v1.Msg.RegisterRelayer:output_type -> tibc.core.client.v1.MsgRegisterRelayerResponse + 9, // [9:13] is the sub-list for method output_type + 5, // [5:9] is the sub-list for method input_type + 5, // [5:5] is the sub-list for extension type_name + 5, // [5:5] is the sub-list for extension extendee + 0, // [0:5] is the sub-list for field type_name +} + +func init() { file_tibc_core_client_v1_tx_proto_init() } +func file_tibc_core_client_v1_tx_proto_init() { + if File_tibc_core_client_v1_tx_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_tibc_core_client_v1_tx_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgUpdateClient); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_tx_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgUpdateClientResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_tx_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgCreateClient); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_tx_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgCreateClientResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_tx_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgUpgradeClient); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_tx_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgUpgradeClientResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_tx_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgRegisterRelayer); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_client_v1_tx_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgRegisterRelayerResponse); 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_tibc_core_client_v1_tx_proto_rawDesc, + NumEnums: 0, + NumMessages: 8, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_tibc_core_client_v1_tx_proto_goTypes, + DependencyIndexes: file_tibc_core_client_v1_tx_proto_depIdxs, + MessageInfos: file_tibc_core_client_v1_tx_proto_msgTypes, + }.Build() + File_tibc_core_client_v1_tx_proto = out.File + file_tibc_core_client_v1_tx_proto_rawDesc = nil + file_tibc_core_client_v1_tx_proto_goTypes = nil + file_tibc_core_client_v1_tx_proto_depIdxs = nil +} diff --git a/api/tibc/core/client/v1/tx_grpc.pb.go b/api/tibc/core/client/v1/tx_grpc.pb.go new file mode 100644 index 00000000..cd6bef93 --- /dev/null +++ b/api/tibc/core/client/v1/tx_grpc.pb.go @@ -0,0 +1,228 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: tibc/core/client/v1/tx.proto + +package clientv1 + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + Msg_CreateClient_FullMethodName = "/tibc.core.client.v1.Msg/CreateClient" + Msg_UpdateClient_FullMethodName = "/tibc.core.client.v1.Msg/UpdateClient" + Msg_UpgradeClient_FullMethodName = "/tibc.core.client.v1.Msg/UpgradeClient" + Msg_RegisterRelayer_FullMethodName = "/tibc.core.client.v1.Msg/RegisterRelayer" +) + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type MsgClient interface { + // CreateClient defines a rpc handler method for MsgCreateClient. + CreateClient(ctx context.Context, in *MsgCreateClient, opts ...grpc.CallOption) (*MsgCreateClientResponse, error) + // UpdateClient defines a rpc handler method for MsgUpdateClient. + UpdateClient(ctx context.Context, in *MsgUpdateClient, opts ...grpc.CallOption) (*MsgUpdateClientResponse, error) + // UpgradeClient defines a rpc handler method for MsgUpgradeClient. + UpgradeClient(ctx context.Context, in *MsgUpgradeClient, opts ...grpc.CallOption) (*MsgUpgradeClientResponse, error) + // RegisterRelayer defines a rpc handler method for MsgRegisterRelayer. + RegisterRelayer(ctx context.Context, in *MsgRegisterRelayer, opts ...grpc.CallOption) (*MsgRegisterRelayerResponse, error) +} + +type msgClient struct { + cc grpc.ClientConnInterface +} + +func NewMsgClient(cc grpc.ClientConnInterface) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) CreateClient(ctx context.Context, in *MsgCreateClient, opts ...grpc.CallOption) (*MsgCreateClientResponse, error) { + out := new(MsgCreateClientResponse) + err := c.cc.Invoke(ctx, Msg_CreateClient_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) UpdateClient(ctx context.Context, in *MsgUpdateClient, opts ...grpc.CallOption) (*MsgUpdateClientResponse, error) { + out := new(MsgUpdateClientResponse) + err := c.cc.Invoke(ctx, Msg_UpdateClient_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) UpgradeClient(ctx context.Context, in *MsgUpgradeClient, opts ...grpc.CallOption) (*MsgUpgradeClientResponse, error) { + out := new(MsgUpgradeClientResponse) + err := c.cc.Invoke(ctx, Msg_UpgradeClient_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) RegisterRelayer(ctx context.Context, in *MsgRegisterRelayer, opts ...grpc.CallOption) (*MsgRegisterRelayerResponse, error) { + out := new(MsgRegisterRelayerResponse) + err := c.cc.Invoke(ctx, Msg_RegisterRelayer_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +// All implementations must embed UnimplementedMsgServer +// for forward compatibility +type MsgServer interface { + // CreateClient defines a rpc handler method for MsgCreateClient. + CreateClient(context.Context, *MsgCreateClient) (*MsgCreateClientResponse, error) + // UpdateClient defines a rpc handler method for MsgUpdateClient. + UpdateClient(context.Context, *MsgUpdateClient) (*MsgUpdateClientResponse, error) + // UpgradeClient defines a rpc handler method for MsgUpgradeClient. + UpgradeClient(context.Context, *MsgUpgradeClient) (*MsgUpgradeClientResponse, error) + // RegisterRelayer defines a rpc handler method for MsgRegisterRelayer. + RegisterRelayer(context.Context, *MsgRegisterRelayer) (*MsgRegisterRelayerResponse, error) + mustEmbedUnimplementedMsgServer() +} + +// UnimplementedMsgServer must be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (UnimplementedMsgServer) CreateClient(context.Context, *MsgCreateClient) (*MsgCreateClientResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CreateClient not implemented") +} +func (UnimplementedMsgServer) UpdateClient(context.Context, *MsgUpdateClient) (*MsgUpdateClientResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateClient not implemented") +} +func (UnimplementedMsgServer) UpgradeClient(context.Context, *MsgUpgradeClient) (*MsgUpgradeClientResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpgradeClient not implemented") +} +func (UnimplementedMsgServer) RegisterRelayer(context.Context, *MsgRegisterRelayer) (*MsgRegisterRelayerResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RegisterRelayer not implemented") +} +func (UnimplementedMsgServer) mustEmbedUnimplementedMsgServer() {} + +// UnsafeMsgServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to MsgServer will +// result in compilation errors. +type UnsafeMsgServer interface { + mustEmbedUnimplementedMsgServer() +} + +func RegisterMsgServer(s grpc.ServiceRegistrar, srv MsgServer) { + s.RegisterService(&Msg_ServiceDesc, srv) +} + +func _Msg_CreateClient_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgCreateClient) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).CreateClient(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Msg_CreateClient_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).CreateClient(ctx, req.(*MsgCreateClient)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_UpdateClient_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateClient) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateClient(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Msg_UpdateClient_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateClient(ctx, req.(*MsgUpdateClient)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_UpgradeClient_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpgradeClient) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpgradeClient(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Msg_UpgradeClient_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpgradeClient(ctx, req.(*MsgUpgradeClient)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_RegisterRelayer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgRegisterRelayer) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).RegisterRelayer(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Msg_RegisterRelayer_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).RegisterRelayer(ctx, req.(*MsgRegisterRelayer)) + } + return interceptor(ctx, in, info, handler) +} + +// Msg_ServiceDesc is the grpc.ServiceDesc for Msg service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Msg_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "tibc.core.client.v1.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "CreateClient", + Handler: _Msg_CreateClient_Handler, + }, + { + MethodName: "UpdateClient", + Handler: _Msg_UpdateClient_Handler, + }, + { + MethodName: "UpgradeClient", + Handler: _Msg_UpgradeClient_Handler, + }, + { + MethodName: "RegisterRelayer", + Handler: _Msg_RegisterRelayer_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "tibc/core/client/v1/tx.proto", +} diff --git a/api/tibc/core/commitment/v1/commitment.pulsar.go b/api/tibc/core/commitment/v1/commitment.pulsar.go new file mode 100644 index 00000000..3f234ba5 --- /dev/null +++ b/api/tibc/core/commitment/v1/commitment.pulsar.go @@ -0,0 +1,2148 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package commitmentv1 + +import ( + fmt "fmt" + runtime "github.com/cosmos/cosmos-proto/runtime" + _ "github.com/cosmos/gogoproto/gogoproto" + _go "github.com/cosmos/ics23/go" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoiface "google.golang.org/protobuf/runtime/protoiface" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_MerkleRoot protoreflect.MessageDescriptor + fd_MerkleRoot_hash protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_commitment_v1_commitment_proto_init() + md_MerkleRoot = File_tibc_core_commitment_v1_commitment_proto.Messages().ByName("MerkleRoot") + fd_MerkleRoot_hash = md_MerkleRoot.Fields().ByName("hash") +} + +var _ protoreflect.Message = (*fastReflection_MerkleRoot)(nil) + +type fastReflection_MerkleRoot MerkleRoot + +func (x *MerkleRoot) ProtoReflect() protoreflect.Message { + return (*fastReflection_MerkleRoot)(x) +} + +func (x *MerkleRoot) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_commitment_v1_commitment_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_MerkleRoot_messageType fastReflection_MerkleRoot_messageType +var _ protoreflect.MessageType = fastReflection_MerkleRoot_messageType{} + +type fastReflection_MerkleRoot_messageType struct{} + +func (x fastReflection_MerkleRoot_messageType) Zero() protoreflect.Message { + return (*fastReflection_MerkleRoot)(nil) +} +func (x fastReflection_MerkleRoot_messageType) New() protoreflect.Message { + return new(fastReflection_MerkleRoot) +} +func (x fastReflection_MerkleRoot_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MerkleRoot +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MerkleRoot) Descriptor() protoreflect.MessageDescriptor { + return md_MerkleRoot +} + +// 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_MerkleRoot) Type() protoreflect.MessageType { + return _fastReflection_MerkleRoot_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MerkleRoot) New() protoreflect.Message { + return new(fastReflection_MerkleRoot) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MerkleRoot) Interface() protoreflect.ProtoMessage { + return (*MerkleRoot)(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_MerkleRoot) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.Hash) != 0 { + value := protoreflect.ValueOfBytes(x.Hash) + if !f(fd_MerkleRoot_hash, 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_MerkleRoot) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.commitment.v1.MerkleRoot.hash": + return len(x.Hash) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerkleRoot")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerkleRoot 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_MerkleRoot) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.commitment.v1.MerkleRoot.hash": + x.Hash = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerkleRoot")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerkleRoot 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_MerkleRoot) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.commitment.v1.MerkleRoot.hash": + value := x.Hash + return protoreflect.ValueOfBytes(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerkleRoot")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerkleRoot 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_MerkleRoot) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.commitment.v1.MerkleRoot.hash": + x.Hash = value.Bytes() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerkleRoot")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerkleRoot 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_MerkleRoot) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.commitment.v1.MerkleRoot.hash": + panic(fmt.Errorf("field hash of message tibc.core.commitment.v1.MerkleRoot is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerkleRoot")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerkleRoot 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_MerkleRoot) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.commitment.v1.MerkleRoot.hash": + return protoreflect.ValueOfBytes(nil) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerkleRoot")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerkleRoot 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_MerkleRoot) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.commitment.v1.MerkleRoot", 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_MerkleRoot) 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_MerkleRoot) 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_MerkleRoot) 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_MerkleRoot) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MerkleRoot) + 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.Hash) + 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().(*MerkleRoot) + 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.Hash) > 0 { + i -= len(x.Hash) + copy(dAtA[i:], x.Hash) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Hash))) + 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().(*MerkleRoot) + 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: MerkleRoot: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MerkleRoot: 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 Hash", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Hash = append(x.Hash[:0], dAtA[iNdEx:postIndex]...) + if x.Hash == nil { + x.Hash = []byte{} + } + 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_MerklePrefix protoreflect.MessageDescriptor + fd_MerklePrefix_key_prefix protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_commitment_v1_commitment_proto_init() + md_MerklePrefix = File_tibc_core_commitment_v1_commitment_proto.Messages().ByName("MerklePrefix") + fd_MerklePrefix_key_prefix = md_MerklePrefix.Fields().ByName("key_prefix") +} + +var _ protoreflect.Message = (*fastReflection_MerklePrefix)(nil) + +type fastReflection_MerklePrefix MerklePrefix + +func (x *MerklePrefix) ProtoReflect() protoreflect.Message { + return (*fastReflection_MerklePrefix)(x) +} + +func (x *MerklePrefix) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_commitment_v1_commitment_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_MerklePrefix_messageType fastReflection_MerklePrefix_messageType +var _ protoreflect.MessageType = fastReflection_MerklePrefix_messageType{} + +type fastReflection_MerklePrefix_messageType struct{} + +func (x fastReflection_MerklePrefix_messageType) Zero() protoreflect.Message { + return (*fastReflection_MerklePrefix)(nil) +} +func (x fastReflection_MerklePrefix_messageType) New() protoreflect.Message { + return new(fastReflection_MerklePrefix) +} +func (x fastReflection_MerklePrefix_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MerklePrefix +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MerklePrefix) Descriptor() protoreflect.MessageDescriptor { + return md_MerklePrefix +} + +// 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_MerklePrefix) Type() protoreflect.MessageType { + return _fastReflection_MerklePrefix_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MerklePrefix) New() protoreflect.Message { + return new(fastReflection_MerklePrefix) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MerklePrefix) Interface() protoreflect.ProtoMessage { + return (*MerklePrefix)(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_MerklePrefix) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.KeyPrefix) != 0 { + value := protoreflect.ValueOfBytes(x.KeyPrefix) + if !f(fd_MerklePrefix_key_prefix, 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_MerklePrefix) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.commitment.v1.MerklePrefix.key_prefix": + return len(x.KeyPrefix) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerklePrefix")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerklePrefix 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_MerklePrefix) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.commitment.v1.MerklePrefix.key_prefix": + x.KeyPrefix = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerklePrefix")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerklePrefix 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_MerklePrefix) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.commitment.v1.MerklePrefix.key_prefix": + value := x.KeyPrefix + return protoreflect.ValueOfBytes(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerklePrefix")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerklePrefix 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_MerklePrefix) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.commitment.v1.MerklePrefix.key_prefix": + x.KeyPrefix = value.Bytes() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerklePrefix")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerklePrefix 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_MerklePrefix) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.commitment.v1.MerklePrefix.key_prefix": + panic(fmt.Errorf("field key_prefix of message tibc.core.commitment.v1.MerklePrefix is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerklePrefix")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerklePrefix 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_MerklePrefix) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.commitment.v1.MerklePrefix.key_prefix": + return protoreflect.ValueOfBytes(nil) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerklePrefix")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerklePrefix 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_MerklePrefix) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.commitment.v1.MerklePrefix", 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_MerklePrefix) 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_MerklePrefix) 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_MerklePrefix) 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_MerklePrefix) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MerklePrefix) + 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.KeyPrefix) + 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().(*MerklePrefix) + 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.KeyPrefix) > 0 { + i -= len(x.KeyPrefix) + copy(dAtA[i:], x.KeyPrefix) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.KeyPrefix))) + 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().(*MerklePrefix) + 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: MerklePrefix: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MerklePrefix: 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 KeyPrefix", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.KeyPrefix = append(x.KeyPrefix[:0], dAtA[iNdEx:postIndex]...) + if x.KeyPrefix == nil { + x.KeyPrefix = []byte{} + } + 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 = (*_MerklePath_1_list)(nil) + +type _MerklePath_1_list struct { + list *[]string +} + +func (x *_MerklePath_1_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_MerklePath_1_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfString((*x.list)[i]) +} + +func (x *_MerklePath_1_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_MerklePath_1_list) Append(value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_MerklePath_1_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message MerklePath at list field KeyPath as it is not of Message kind")) +} + +func (x *_MerklePath_1_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_MerklePath_1_list) NewElement() protoreflect.Value { + v := "" + return protoreflect.ValueOfString(v) +} + +func (x *_MerklePath_1_list) IsValid() bool { + return x.list != nil +} + +var ( + md_MerklePath protoreflect.MessageDescriptor + fd_MerklePath_key_path protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_commitment_v1_commitment_proto_init() + md_MerklePath = File_tibc_core_commitment_v1_commitment_proto.Messages().ByName("MerklePath") + fd_MerklePath_key_path = md_MerklePath.Fields().ByName("key_path") +} + +var _ protoreflect.Message = (*fastReflection_MerklePath)(nil) + +type fastReflection_MerklePath MerklePath + +func (x *MerklePath) ProtoReflect() protoreflect.Message { + return (*fastReflection_MerklePath)(x) +} + +func (x *MerklePath) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_commitment_v1_commitment_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_MerklePath_messageType fastReflection_MerklePath_messageType +var _ protoreflect.MessageType = fastReflection_MerklePath_messageType{} + +type fastReflection_MerklePath_messageType struct{} + +func (x fastReflection_MerklePath_messageType) Zero() protoreflect.Message { + return (*fastReflection_MerklePath)(nil) +} +func (x fastReflection_MerklePath_messageType) New() protoreflect.Message { + return new(fastReflection_MerklePath) +} +func (x fastReflection_MerklePath_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MerklePath +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MerklePath) Descriptor() protoreflect.MessageDescriptor { + return md_MerklePath +} + +// 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_MerklePath) Type() protoreflect.MessageType { + return _fastReflection_MerklePath_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MerklePath) New() protoreflect.Message { + return new(fastReflection_MerklePath) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MerklePath) Interface() protoreflect.ProtoMessage { + return (*MerklePath)(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_MerklePath) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.KeyPath) != 0 { + value := protoreflect.ValueOfList(&_MerklePath_1_list{list: &x.KeyPath}) + if !f(fd_MerklePath_key_path, 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_MerklePath) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.commitment.v1.MerklePath.key_path": + return len(x.KeyPath) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerklePath")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerklePath 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_MerklePath) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.commitment.v1.MerklePath.key_path": + x.KeyPath = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerklePath")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerklePath 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_MerklePath) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.commitment.v1.MerklePath.key_path": + if len(x.KeyPath) == 0 { + return protoreflect.ValueOfList(&_MerklePath_1_list{}) + } + listValue := &_MerklePath_1_list{list: &x.KeyPath} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerklePath")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerklePath 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_MerklePath) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.commitment.v1.MerklePath.key_path": + lv := value.List() + clv := lv.(*_MerklePath_1_list) + x.KeyPath = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerklePath")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerklePath 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_MerklePath) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.commitment.v1.MerklePath.key_path": + if x.KeyPath == nil { + x.KeyPath = []string{} + } + value := &_MerklePath_1_list{list: &x.KeyPath} + return protoreflect.ValueOfList(value) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerklePath")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerklePath 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_MerklePath) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.commitment.v1.MerklePath.key_path": + list := []string{} + return protoreflect.ValueOfList(&_MerklePath_1_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerklePath")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerklePath 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_MerklePath) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.commitment.v1.MerklePath", 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_MerklePath) 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_MerklePath) 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_MerklePath) 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_MerklePath) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MerklePath) + 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.KeyPath) > 0 { + for _, s := range x.KeyPath { + l = len(s) + 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().(*MerklePath) + 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.KeyPath) > 0 { + for iNdEx := len(x.KeyPath) - 1; iNdEx >= 0; iNdEx-- { + i -= len(x.KeyPath[iNdEx]) + copy(dAtA[i:], x.KeyPath[iNdEx]) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.KeyPath[iNdEx]))) + 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().(*MerklePath) + 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: MerklePath: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MerklePath: 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 KeyPath", 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.KeyPath = append(x.KeyPath, 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 = (*_MerkleProof_1_list)(nil) + +type _MerkleProof_1_list struct { + list *[]*_go.CommitmentProof +} + +func (x *_MerkleProof_1_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_MerkleProof_1_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_MerkleProof_1_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*_go.CommitmentProof) + (*x.list)[i] = concreteValue +} + +func (x *_MerkleProof_1_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*_go.CommitmentProof) + *x.list = append(*x.list, concreteValue) +} + +func (x *_MerkleProof_1_list) AppendMutable() protoreflect.Value { + v := new(_go.CommitmentProof) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_MerkleProof_1_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_MerkleProof_1_list) NewElement() protoreflect.Value { + v := new(_go.CommitmentProof) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_MerkleProof_1_list) IsValid() bool { + return x.list != nil +} + +var ( + md_MerkleProof protoreflect.MessageDescriptor + fd_MerkleProof_proofs protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_commitment_v1_commitment_proto_init() + md_MerkleProof = File_tibc_core_commitment_v1_commitment_proto.Messages().ByName("MerkleProof") + fd_MerkleProof_proofs = md_MerkleProof.Fields().ByName("proofs") +} + +var _ protoreflect.Message = (*fastReflection_MerkleProof)(nil) + +type fastReflection_MerkleProof MerkleProof + +func (x *MerkleProof) ProtoReflect() protoreflect.Message { + return (*fastReflection_MerkleProof)(x) +} + +func (x *MerkleProof) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_commitment_v1_commitment_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_MerkleProof_messageType fastReflection_MerkleProof_messageType +var _ protoreflect.MessageType = fastReflection_MerkleProof_messageType{} + +type fastReflection_MerkleProof_messageType struct{} + +func (x fastReflection_MerkleProof_messageType) Zero() protoreflect.Message { + return (*fastReflection_MerkleProof)(nil) +} +func (x fastReflection_MerkleProof_messageType) New() protoreflect.Message { + return new(fastReflection_MerkleProof) +} +func (x fastReflection_MerkleProof_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MerkleProof +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MerkleProof) Descriptor() protoreflect.MessageDescriptor { + return md_MerkleProof +} + +// 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_MerkleProof) Type() protoreflect.MessageType { + return _fastReflection_MerkleProof_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MerkleProof) New() protoreflect.Message { + return new(fastReflection_MerkleProof) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MerkleProof) Interface() protoreflect.ProtoMessage { + return (*MerkleProof)(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_MerkleProof) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.Proofs) != 0 { + value := protoreflect.ValueOfList(&_MerkleProof_1_list{list: &x.Proofs}) + if !f(fd_MerkleProof_proofs, 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_MerkleProof) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.commitment.v1.MerkleProof.proofs": + return len(x.Proofs) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerkleProof")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerkleProof 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_MerkleProof) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.commitment.v1.MerkleProof.proofs": + x.Proofs = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerkleProof")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerkleProof 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_MerkleProof) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.commitment.v1.MerkleProof.proofs": + if len(x.Proofs) == 0 { + return protoreflect.ValueOfList(&_MerkleProof_1_list{}) + } + listValue := &_MerkleProof_1_list{list: &x.Proofs} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerkleProof")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerkleProof 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_MerkleProof) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.commitment.v1.MerkleProof.proofs": + lv := value.List() + clv := lv.(*_MerkleProof_1_list) + x.Proofs = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerkleProof")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerkleProof 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_MerkleProof) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.commitment.v1.MerkleProof.proofs": + if x.Proofs == nil { + x.Proofs = []*_go.CommitmentProof{} + } + value := &_MerkleProof_1_list{list: &x.Proofs} + return protoreflect.ValueOfList(value) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerkleProof")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerkleProof 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_MerkleProof) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.commitment.v1.MerkleProof.proofs": + list := []*_go.CommitmentProof{} + return protoreflect.ValueOfList(&_MerkleProof_1_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.commitment.v1.MerkleProof")) + } + panic(fmt.Errorf("message tibc.core.commitment.v1.MerkleProof 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_MerkleProof) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.commitment.v1.MerkleProof", 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_MerkleProof) 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_MerkleProof) 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_MerkleProof) 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_MerkleProof) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MerkleProof) + 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.Proofs) > 0 { + for _, e := range x.Proofs { + 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().(*MerkleProof) + 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.Proofs) > 0 { + for iNdEx := len(x.Proofs) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.Proofs[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().(*MerkleProof) + 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: MerkleProof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MerkleProof: 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 Proofs", 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.Proofs = append(x.Proofs, &_go.CommitmentProof{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Proofs[len(x.Proofs)-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: tibc/core/commitment/v1/commitment.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) +) + +// MerkleRoot defines a merkle root hash. +// In the Cosmos SDK, the AppHash of a block header becomes the root. +type MerkleRoot struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"` +} + +func (x *MerkleRoot) Reset() { + *x = MerkleRoot{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_commitment_v1_commitment_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MerkleRoot) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MerkleRoot) ProtoMessage() {} + +// Deprecated: Use MerkleRoot.ProtoReflect.Descriptor instead. +func (*MerkleRoot) Descriptor() ([]byte, []int) { + return file_tibc_core_commitment_v1_commitment_proto_rawDescGZIP(), []int{0} +} + +func (x *MerkleRoot) GetHash() []byte { + if x != nil { + return x.Hash + } + return nil +} + +// MerklePrefix is merkle path prefixed to the key. +// The constructed key from the Path and the key will be append(Path.KeyPath, +// append(Path.KeyPrefix, key...)) +type MerklePrefix struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + KeyPrefix []byte `protobuf:"bytes,1,opt,name=key_prefix,json=keyPrefix,proto3" json:"key_prefix,omitempty"` +} + +func (x *MerklePrefix) Reset() { + *x = MerklePrefix{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_commitment_v1_commitment_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MerklePrefix) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MerklePrefix) ProtoMessage() {} + +// Deprecated: Use MerklePrefix.ProtoReflect.Descriptor instead. +func (*MerklePrefix) Descriptor() ([]byte, []int) { + return file_tibc_core_commitment_v1_commitment_proto_rawDescGZIP(), []int{1} +} + +func (x *MerklePrefix) GetKeyPrefix() []byte { + if x != nil { + return x.KeyPrefix + } + return nil +} + +// MerklePath is the path used to verify commitment proofs, which can be an +// arbitrary structured object (defined by a commitment type). +// MerklePath is represented from root-to-leaf +type MerklePath struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + KeyPath []string `protobuf:"bytes,1,rep,name=key_path,json=keyPath,proto3" json:"key_path,omitempty"` +} + +func (x *MerklePath) Reset() { + *x = MerklePath{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_commitment_v1_commitment_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MerklePath) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MerklePath) ProtoMessage() {} + +// Deprecated: Use MerklePath.ProtoReflect.Descriptor instead. +func (*MerklePath) Descriptor() ([]byte, []int) { + return file_tibc_core_commitment_v1_commitment_proto_rawDescGZIP(), []int{2} +} + +func (x *MerklePath) GetKeyPath() []string { + if x != nil { + return x.KeyPath + } + return nil +} + +// MerkleProof is a wrapper type over a chain of CommitmentProofs. +// It demonstrates membership or non-membership for an element or set of +// elements, verifiable in conjunction with a known commitment root. Proofs +// should be succinct. +// MerkleProofs are ordered from leaf-to-root +type MerkleProof struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Proofs []*_go.CommitmentProof `protobuf:"bytes,1,rep,name=proofs,proto3" json:"proofs,omitempty"` +} + +func (x *MerkleProof) Reset() { + *x = MerkleProof{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_commitment_v1_commitment_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MerkleProof) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MerkleProof) ProtoMessage() {} + +// Deprecated: Use MerkleProof.ProtoReflect.Descriptor instead. +func (*MerkleProof) Descriptor() ([]byte, []int) { + return file_tibc_core_commitment_v1_commitment_proto_rawDescGZIP(), []int{3} +} + +func (x *MerkleProof) GetProofs() []*_go.CommitmentProof { + if x != nil { + return x.Proofs + } + return nil +} + +var File_tibc_core_commitment_v1_commitment_proto protoreflect.FileDescriptor + +var file_tibc_core_commitment_v1_commitment_proto_rawDesc = []byte{ + 0x0a, 0x28, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, + 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, + 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x17, 0x74, 0x69, 0x62, 0x63, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, + 0x2e, 0x76, 0x31, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, + 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x63, 0x6f, 0x73, 0x6d, 0x6f, + 0x73, 0x2f, 0x69, 0x63, 0x73, 0x32, 0x33, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6f, 0x66, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x26, 0x0a, 0x0a, 0x4d, 0x65, 0x72, 0x6b, 0x6c, + 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x04, 0x68, 0x61, 0x73, 0x68, 0x3a, 0x04, 0x88, 0xa0, 0x1f, 0x00, 0x22, + 0x44, 0x0a, 0x0c, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, + 0x34, 0x0a, 0x0a, 0x6b, 0x65, 0x79, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0c, 0x42, 0x15, 0xf2, 0xde, 0x1f, 0x11, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x6b, + 0x65, 0x79, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x22, 0x52, 0x09, 0x6b, 0x65, 0x79, 0x50, + 0x72, 0x65, 0x66, 0x69, 0x78, 0x22, 0x42, 0x0a, 0x0a, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x50, + 0x61, 0x74, 0x68, 0x12, 0x2e, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x09, 0x42, 0x13, 0xf2, 0xde, 0x1f, 0x0f, 0x79, 0x61, 0x6d, 0x6c, 0x3a, + 0x22, 0x6b, 0x65, 0x79, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x22, 0x52, 0x07, 0x6b, 0x65, 0x79, 0x50, + 0x61, 0x74, 0x68, 0x3a, 0x04, 0x98, 0xa0, 0x1f, 0x00, 0x22, 0x47, 0x0a, 0x0b, 0x4d, 0x65, 0x72, + 0x6b, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x38, 0x0a, 0x06, 0x70, 0x72, 0x6f, 0x6f, + 0x66, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, + 0x73, 0x2e, 0x69, 0x63, 0x73, 0x32, 0x33, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, + 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x06, 0x70, 0x72, 0x6f, 0x6f, + 0x66, 0x73, 0x42, 0xf4, 0x01, 0x0a, 0x1b, 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x2e, + 0x76, 0x31, 0x42, 0x0f, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x45, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, + 0x6d, 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, + 0x2d, 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, + 0x65, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x3b, + 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x54, + 0x43, 0x43, 0xaa, 0x02, 0x17, 0x54, 0x69, 0x62, 0x63, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0x2e, 0x43, + 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x17, 0x54, + 0x69, 0x62, 0x63, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, + 0x65, 0x6e, 0x74, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x23, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x43, 0x6f, + 0x72, 0x65, 0x5c, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x5c, 0x56, 0x31, + 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x1a, 0x54, + 0x69, 0x62, 0x63, 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, 0x6d, 0x69, + 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x33, +} + +var ( + file_tibc_core_commitment_v1_commitment_proto_rawDescOnce sync.Once + file_tibc_core_commitment_v1_commitment_proto_rawDescData = file_tibc_core_commitment_v1_commitment_proto_rawDesc +) + +func file_tibc_core_commitment_v1_commitment_proto_rawDescGZIP() []byte { + file_tibc_core_commitment_v1_commitment_proto_rawDescOnce.Do(func() { + file_tibc_core_commitment_v1_commitment_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_core_commitment_v1_commitment_proto_rawDescData) + }) + return file_tibc_core_commitment_v1_commitment_proto_rawDescData +} + +var file_tibc_core_commitment_v1_commitment_proto_msgTypes = make([]protoimpl.MessageInfo, 4) +var file_tibc_core_commitment_v1_commitment_proto_goTypes = []interface{}{ + (*MerkleRoot)(nil), // 0: tibc.core.commitment.v1.MerkleRoot + (*MerklePrefix)(nil), // 1: tibc.core.commitment.v1.MerklePrefix + (*MerklePath)(nil), // 2: tibc.core.commitment.v1.MerklePath + (*MerkleProof)(nil), // 3: tibc.core.commitment.v1.MerkleProof + (*_go.CommitmentProof)(nil), // 4: cosmos.ics23.v1.CommitmentProof +} +var file_tibc_core_commitment_v1_commitment_proto_depIdxs = []int32{ + 4, // 0: tibc.core.commitment.v1.MerkleProof.proofs:type_name -> cosmos.ics23.v1.CommitmentProof + 1, // [1:1] is the sub-list for method output_type + 1, // [1:1] is the sub-list for method input_type + 1, // [1:1] is the sub-list for extension type_name + 1, // [1:1] is the sub-list for extension extendee + 0, // [0:1] is the sub-list for field type_name +} + +func init() { file_tibc_core_commitment_v1_commitment_proto_init() } +func file_tibc_core_commitment_v1_commitment_proto_init() { + if File_tibc_core_commitment_v1_commitment_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_tibc_core_commitment_v1_commitment_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MerkleRoot); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_commitment_v1_commitment_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MerklePrefix); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_commitment_v1_commitment_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MerklePath); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_commitment_v1_commitment_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MerkleProof); 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_tibc_core_commitment_v1_commitment_proto_rawDesc, + NumEnums: 0, + NumMessages: 4, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_tibc_core_commitment_v1_commitment_proto_goTypes, + DependencyIndexes: file_tibc_core_commitment_v1_commitment_proto_depIdxs, + MessageInfos: file_tibc_core_commitment_v1_commitment_proto_msgTypes, + }.Build() + File_tibc_core_commitment_v1_commitment_proto = out.File + file_tibc_core_commitment_v1_commitment_proto_rawDesc = nil + file_tibc_core_commitment_v1_commitment_proto_goTypes = nil + file_tibc_core_commitment_v1_commitment_proto_depIdxs = nil +} diff --git a/api/tibc/core/packet/v1/genesis.pulsar.go b/api/tibc/core/packet/v1/genesis.pulsar.go new file mode 100644 index 00000000..f26ef560 --- /dev/null +++ b/api/tibc/core/packet/v1/genesis.pulsar.go @@ -0,0 +1,2029 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package packetv1 + +import ( + fmt "fmt" + 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" + io "io" + reflect "reflect" + sync "sync" +) + +var _ protoreflect.List = (*_GenesisState_2_list)(nil) + +type _GenesisState_2_list struct { + list *[]*PacketState +} + +func (x *_GenesisState_2_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_GenesisState_2_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_GenesisState_2_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*PacketState) + (*x.list)[i] = concreteValue +} + +func (x *_GenesisState_2_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*PacketState) + *x.list = append(*x.list, concreteValue) +} + +func (x *_GenesisState_2_list) AppendMutable() protoreflect.Value { + v := new(PacketState) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_GenesisState_2_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_GenesisState_2_list) NewElement() protoreflect.Value { + v := new(PacketState) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_GenesisState_2_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_GenesisState_3_list)(nil) + +type _GenesisState_3_list struct { + list *[]*PacketState +} + +func (x *_GenesisState_3_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_GenesisState_3_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_GenesisState_3_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*PacketState) + (*x.list)[i] = concreteValue +} + +func (x *_GenesisState_3_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*PacketState) + *x.list = append(*x.list, concreteValue) +} + +func (x *_GenesisState_3_list) AppendMutable() protoreflect.Value { + v := new(PacketState) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_GenesisState_3_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_GenesisState_3_list) NewElement() protoreflect.Value { + v := new(PacketState) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_GenesisState_3_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_GenesisState_4_list)(nil) + +type _GenesisState_4_list struct { + list *[]*PacketState +} + +func (x *_GenesisState_4_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_GenesisState_4_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_GenesisState_4_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*PacketState) + (*x.list)[i] = concreteValue +} + +func (x *_GenesisState_4_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*PacketState) + *x.list = append(*x.list, concreteValue) +} + +func (x *_GenesisState_4_list) AppendMutable() protoreflect.Value { + v := new(PacketState) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_GenesisState_4_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_GenesisState_4_list) NewElement() protoreflect.Value { + v := new(PacketState) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_GenesisState_4_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_GenesisState_5_list)(nil) + +type _GenesisState_5_list struct { + list *[]*PacketSequence +} + +func (x *_GenesisState_5_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_GenesisState_5_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_GenesisState_5_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*PacketSequence) + (*x.list)[i] = concreteValue +} + +func (x *_GenesisState_5_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*PacketSequence) + *x.list = append(*x.list, concreteValue) +} + +func (x *_GenesisState_5_list) AppendMutable() protoreflect.Value { + v := new(PacketSequence) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_GenesisState_5_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_GenesisState_5_list) NewElement() protoreflect.Value { + v := new(PacketSequence) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_GenesisState_5_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_GenesisState_6_list)(nil) + +type _GenesisState_6_list struct { + list *[]*PacketSequence +} + +func (x *_GenesisState_6_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_GenesisState_6_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_GenesisState_6_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*PacketSequence) + (*x.list)[i] = concreteValue +} + +func (x *_GenesisState_6_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*PacketSequence) + *x.list = append(*x.list, concreteValue) +} + +func (x *_GenesisState_6_list) AppendMutable() protoreflect.Value { + v := new(PacketSequence) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_GenesisState_6_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_GenesisState_6_list) NewElement() protoreflect.Value { + v := new(PacketSequence) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_GenesisState_6_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_GenesisState_7_list)(nil) + +type _GenesisState_7_list struct { + list *[]*PacketSequence +} + +func (x *_GenesisState_7_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_GenesisState_7_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_GenesisState_7_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*PacketSequence) + (*x.list)[i] = concreteValue +} + +func (x *_GenesisState_7_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*PacketSequence) + *x.list = append(*x.list, concreteValue) +} + +func (x *_GenesisState_7_list) AppendMutable() protoreflect.Value { + v := new(PacketSequence) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_GenesisState_7_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_GenesisState_7_list) NewElement() protoreflect.Value { + v := new(PacketSequence) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_GenesisState_7_list) IsValid() bool { + return x.list != nil +} + +var ( + md_GenesisState protoreflect.MessageDescriptor + fd_GenesisState_acknowledgements protoreflect.FieldDescriptor + fd_GenesisState_commitments protoreflect.FieldDescriptor + fd_GenesisState_receipts protoreflect.FieldDescriptor + fd_GenesisState_send_sequences protoreflect.FieldDescriptor + fd_GenesisState_recv_sequences protoreflect.FieldDescriptor + fd_GenesisState_ack_sequences protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_genesis_proto_init() + md_GenesisState = File_tibc_core_packet_v1_genesis_proto.Messages().ByName("GenesisState") + fd_GenesisState_acknowledgements = md_GenesisState.Fields().ByName("acknowledgements") + fd_GenesisState_commitments = md_GenesisState.Fields().ByName("commitments") + fd_GenesisState_receipts = md_GenesisState.Fields().ByName("receipts") + fd_GenesisState_send_sequences = md_GenesisState.Fields().ByName("send_sequences") + fd_GenesisState_recv_sequences = md_GenesisState.Fields().ByName("recv_sequences") + fd_GenesisState_ack_sequences = md_GenesisState.Fields().ByName("ack_sequences") +} + +var _ protoreflect.Message = (*fastReflection_GenesisState)(nil) + +type fastReflection_GenesisState GenesisState + +func (x *GenesisState) ProtoReflect() protoreflect.Message { + return (*fastReflection_GenesisState)(x) +} + +func (x *GenesisState) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_genesis_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_GenesisState_messageType fastReflection_GenesisState_messageType +var _ protoreflect.MessageType = fastReflection_GenesisState_messageType{} + +type fastReflection_GenesisState_messageType struct{} + +func (x fastReflection_GenesisState_messageType) Zero() protoreflect.Message { + return (*fastReflection_GenesisState)(nil) +} +func (x fastReflection_GenesisState_messageType) New() protoreflect.Message { + return new(fastReflection_GenesisState) +} +func (x fastReflection_GenesisState_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_GenesisState +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_GenesisState) Descriptor() protoreflect.MessageDescriptor { + return md_GenesisState +} + +// 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_GenesisState) Type() protoreflect.MessageType { + return _fastReflection_GenesisState_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_GenesisState) New() protoreflect.Message { + return new(fastReflection_GenesisState) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_GenesisState) Interface() protoreflect.ProtoMessage { + return (*GenesisState)(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_GenesisState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.Acknowledgements) != 0 { + value := protoreflect.ValueOfList(&_GenesisState_2_list{list: &x.Acknowledgements}) + if !f(fd_GenesisState_acknowledgements, value) { + return + } + } + if len(x.Commitments) != 0 { + value := protoreflect.ValueOfList(&_GenesisState_3_list{list: &x.Commitments}) + if !f(fd_GenesisState_commitments, value) { + return + } + } + if len(x.Receipts) != 0 { + value := protoreflect.ValueOfList(&_GenesisState_4_list{list: &x.Receipts}) + if !f(fd_GenesisState_receipts, value) { + return + } + } + if len(x.SendSequences) != 0 { + value := protoreflect.ValueOfList(&_GenesisState_5_list{list: &x.SendSequences}) + if !f(fd_GenesisState_send_sequences, value) { + return + } + } + if len(x.RecvSequences) != 0 { + value := protoreflect.ValueOfList(&_GenesisState_6_list{list: &x.RecvSequences}) + if !f(fd_GenesisState_recv_sequences, value) { + return + } + } + if len(x.AckSequences) != 0 { + value := protoreflect.ValueOfList(&_GenesisState_7_list{list: &x.AckSequences}) + if !f(fd_GenesisState_ack_sequences, 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_GenesisState) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.GenesisState.acknowledgements": + return len(x.Acknowledgements) != 0 + case "tibc.core.packet.v1.GenesisState.commitments": + return len(x.Commitments) != 0 + case "tibc.core.packet.v1.GenesisState.receipts": + return len(x.Receipts) != 0 + case "tibc.core.packet.v1.GenesisState.send_sequences": + return len(x.SendSequences) != 0 + case "tibc.core.packet.v1.GenesisState.recv_sequences": + return len(x.RecvSequences) != 0 + case "tibc.core.packet.v1.GenesisState.ack_sequences": + return len(x.AckSequences) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.GenesisState 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_GenesisState) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.GenesisState.acknowledgements": + x.Acknowledgements = nil + case "tibc.core.packet.v1.GenesisState.commitments": + x.Commitments = nil + case "tibc.core.packet.v1.GenesisState.receipts": + x.Receipts = nil + case "tibc.core.packet.v1.GenesisState.send_sequences": + x.SendSequences = nil + case "tibc.core.packet.v1.GenesisState.recv_sequences": + x.RecvSequences = nil + case "tibc.core.packet.v1.GenesisState.ack_sequences": + x.AckSequences = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.GenesisState 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_GenesisState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.GenesisState.acknowledgements": + if len(x.Acknowledgements) == 0 { + return protoreflect.ValueOfList(&_GenesisState_2_list{}) + } + listValue := &_GenesisState_2_list{list: &x.Acknowledgements} + return protoreflect.ValueOfList(listValue) + case "tibc.core.packet.v1.GenesisState.commitments": + if len(x.Commitments) == 0 { + return protoreflect.ValueOfList(&_GenesisState_3_list{}) + } + listValue := &_GenesisState_3_list{list: &x.Commitments} + return protoreflect.ValueOfList(listValue) + case "tibc.core.packet.v1.GenesisState.receipts": + if len(x.Receipts) == 0 { + return protoreflect.ValueOfList(&_GenesisState_4_list{}) + } + listValue := &_GenesisState_4_list{list: &x.Receipts} + return protoreflect.ValueOfList(listValue) + case "tibc.core.packet.v1.GenesisState.send_sequences": + if len(x.SendSequences) == 0 { + return protoreflect.ValueOfList(&_GenesisState_5_list{}) + } + listValue := &_GenesisState_5_list{list: &x.SendSequences} + return protoreflect.ValueOfList(listValue) + case "tibc.core.packet.v1.GenesisState.recv_sequences": + if len(x.RecvSequences) == 0 { + return protoreflect.ValueOfList(&_GenesisState_6_list{}) + } + listValue := &_GenesisState_6_list{list: &x.RecvSequences} + return protoreflect.ValueOfList(listValue) + case "tibc.core.packet.v1.GenesisState.ack_sequences": + if len(x.AckSequences) == 0 { + return protoreflect.ValueOfList(&_GenesisState_7_list{}) + } + listValue := &_GenesisState_7_list{list: &x.AckSequences} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.GenesisState 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_GenesisState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.GenesisState.acknowledgements": + lv := value.List() + clv := lv.(*_GenesisState_2_list) + x.Acknowledgements = *clv.list + case "tibc.core.packet.v1.GenesisState.commitments": + lv := value.List() + clv := lv.(*_GenesisState_3_list) + x.Commitments = *clv.list + case "tibc.core.packet.v1.GenesisState.receipts": + lv := value.List() + clv := lv.(*_GenesisState_4_list) + x.Receipts = *clv.list + case "tibc.core.packet.v1.GenesisState.send_sequences": + lv := value.List() + clv := lv.(*_GenesisState_5_list) + x.SendSequences = *clv.list + case "tibc.core.packet.v1.GenesisState.recv_sequences": + lv := value.List() + clv := lv.(*_GenesisState_6_list) + x.RecvSequences = *clv.list + case "tibc.core.packet.v1.GenesisState.ack_sequences": + lv := value.List() + clv := lv.(*_GenesisState_7_list) + x.AckSequences = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.GenesisState 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_GenesisState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.GenesisState.acknowledgements": + if x.Acknowledgements == nil { + x.Acknowledgements = []*PacketState{} + } + value := &_GenesisState_2_list{list: &x.Acknowledgements} + return protoreflect.ValueOfList(value) + case "tibc.core.packet.v1.GenesisState.commitments": + if x.Commitments == nil { + x.Commitments = []*PacketState{} + } + value := &_GenesisState_3_list{list: &x.Commitments} + return protoreflect.ValueOfList(value) + case "tibc.core.packet.v1.GenesisState.receipts": + if x.Receipts == nil { + x.Receipts = []*PacketState{} + } + value := &_GenesisState_4_list{list: &x.Receipts} + return protoreflect.ValueOfList(value) + case "tibc.core.packet.v1.GenesisState.send_sequences": + if x.SendSequences == nil { + x.SendSequences = []*PacketSequence{} + } + value := &_GenesisState_5_list{list: &x.SendSequences} + return protoreflect.ValueOfList(value) + case "tibc.core.packet.v1.GenesisState.recv_sequences": + if x.RecvSequences == nil { + x.RecvSequences = []*PacketSequence{} + } + value := &_GenesisState_6_list{list: &x.RecvSequences} + return protoreflect.ValueOfList(value) + case "tibc.core.packet.v1.GenesisState.ack_sequences": + if x.AckSequences == nil { + x.AckSequences = []*PacketSequence{} + } + value := &_GenesisState_7_list{list: &x.AckSequences} + return protoreflect.ValueOfList(value) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.GenesisState 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_GenesisState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.GenesisState.acknowledgements": + list := []*PacketState{} + return protoreflect.ValueOfList(&_GenesisState_2_list{list: &list}) + case "tibc.core.packet.v1.GenesisState.commitments": + list := []*PacketState{} + return protoreflect.ValueOfList(&_GenesisState_3_list{list: &list}) + case "tibc.core.packet.v1.GenesisState.receipts": + list := []*PacketState{} + return protoreflect.ValueOfList(&_GenesisState_4_list{list: &list}) + case "tibc.core.packet.v1.GenesisState.send_sequences": + list := []*PacketSequence{} + return protoreflect.ValueOfList(&_GenesisState_5_list{list: &list}) + case "tibc.core.packet.v1.GenesisState.recv_sequences": + list := []*PacketSequence{} + return protoreflect.ValueOfList(&_GenesisState_6_list{list: &list}) + case "tibc.core.packet.v1.GenesisState.ack_sequences": + list := []*PacketSequence{} + return protoreflect.ValueOfList(&_GenesisState_7_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.GenesisState 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_GenesisState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.GenesisState", 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_GenesisState) 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_GenesisState) 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_GenesisState) 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_GenesisState) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*GenesisState) + 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.Acknowledgements) > 0 { + for _, e := range x.Acknowledgements { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if len(x.Commitments) > 0 { + for _, e := range x.Commitments { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if len(x.Receipts) > 0 { + for _, e := range x.Receipts { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if len(x.SendSequences) > 0 { + for _, e := range x.SendSequences { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if len(x.RecvSequences) > 0 { + for _, e := range x.RecvSequences { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if len(x.AckSequences) > 0 { + for _, e := range x.AckSequences { + 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().(*GenesisState) + 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.AckSequences) > 0 { + for iNdEx := len(x.AckSequences) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.AckSequences[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] = 0x3a + } + } + if len(x.RecvSequences) > 0 { + for iNdEx := len(x.RecvSequences) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.RecvSequences[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] = 0x32 + } + } + if len(x.SendSequences) > 0 { + for iNdEx := len(x.SendSequences) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.SendSequences[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] = 0x2a + } + } + if len(x.Receipts) > 0 { + for iNdEx := len(x.Receipts) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.Receipts[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] = 0x22 + } + } + if len(x.Commitments) > 0 { + for iNdEx := len(x.Commitments) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.Commitments[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.Acknowledgements) > 0 { + for iNdEx := len(x.Acknowledgements) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.Acknowledgements[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] = 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().(*GenesisState) + 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: GenesisState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GenesisState: 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 Acknowledgements", 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.Acknowledgements = append(x.Acknowledgements, &PacketState{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Acknowledgements[len(x.Acknowledgements)-1]); 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 Commitments", 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.Commitments = append(x.Commitments, &PacketState{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Commitments[len(x.Commitments)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Receipts", 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.Receipts = append(x.Receipts, &PacketState{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Receipts[len(x.Receipts)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SendSequences", 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.SendSequences = append(x.SendSequences, &PacketSequence{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.SendSequences[len(x.SendSequences)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RecvSequences", 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.RecvSequences = append(x.RecvSequences, &PacketSequence{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.RecvSequences[len(x.RecvSequences)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field AckSequences", 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.AckSequences = append(x.AckSequences, &PacketSequence{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.AckSequences[len(x.AckSequences)-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_PacketSequence protoreflect.MessageDescriptor + fd_PacketSequence_source_chain protoreflect.FieldDescriptor + fd_PacketSequence_destination_chain protoreflect.FieldDescriptor + fd_PacketSequence_sequence protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_genesis_proto_init() + md_PacketSequence = File_tibc_core_packet_v1_genesis_proto.Messages().ByName("PacketSequence") + fd_PacketSequence_source_chain = md_PacketSequence.Fields().ByName("source_chain") + fd_PacketSequence_destination_chain = md_PacketSequence.Fields().ByName("destination_chain") + fd_PacketSequence_sequence = md_PacketSequence.Fields().ByName("sequence") +} + +var _ protoreflect.Message = (*fastReflection_PacketSequence)(nil) + +type fastReflection_PacketSequence PacketSequence + +func (x *PacketSequence) ProtoReflect() protoreflect.Message { + return (*fastReflection_PacketSequence)(x) +} + +func (x *PacketSequence) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_genesis_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_PacketSequence_messageType fastReflection_PacketSequence_messageType +var _ protoreflect.MessageType = fastReflection_PacketSequence_messageType{} + +type fastReflection_PacketSequence_messageType struct{} + +func (x fastReflection_PacketSequence_messageType) Zero() protoreflect.Message { + return (*fastReflection_PacketSequence)(nil) +} +func (x fastReflection_PacketSequence_messageType) New() protoreflect.Message { + return new(fastReflection_PacketSequence) +} +func (x fastReflection_PacketSequence_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_PacketSequence +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_PacketSequence) Descriptor() protoreflect.MessageDescriptor { + return md_PacketSequence +} + +// 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_PacketSequence) Type() protoreflect.MessageType { + return _fastReflection_PacketSequence_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_PacketSequence) New() protoreflect.Message { + return new(fastReflection_PacketSequence) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_PacketSequence) Interface() protoreflect.ProtoMessage { + return (*PacketSequence)(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_PacketSequence) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.SourceChain != "" { + value := protoreflect.ValueOfString(x.SourceChain) + if !f(fd_PacketSequence_source_chain, value) { + return + } + } + if x.DestinationChain != "" { + value := protoreflect.ValueOfString(x.DestinationChain) + if !f(fd_PacketSequence_destination_chain, value) { + return + } + } + if x.Sequence != uint64(0) { + value := protoreflect.ValueOfUint64(x.Sequence) + if !f(fd_PacketSequence_sequence, 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_PacketSequence) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.PacketSequence.source_chain": + return x.SourceChain != "" + case "tibc.core.packet.v1.PacketSequence.destination_chain": + return x.DestinationChain != "" + case "tibc.core.packet.v1.PacketSequence.sequence": + return x.Sequence != uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.PacketSequence")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.PacketSequence 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_PacketSequence) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.PacketSequence.source_chain": + x.SourceChain = "" + case "tibc.core.packet.v1.PacketSequence.destination_chain": + x.DestinationChain = "" + case "tibc.core.packet.v1.PacketSequence.sequence": + x.Sequence = uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.PacketSequence")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.PacketSequence 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_PacketSequence) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.PacketSequence.source_chain": + value := x.SourceChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.PacketSequence.destination_chain": + value := x.DestinationChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.PacketSequence.sequence": + value := x.Sequence + return protoreflect.ValueOfUint64(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.PacketSequence")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.PacketSequence 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_PacketSequence) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.PacketSequence.source_chain": + x.SourceChain = value.Interface().(string) + case "tibc.core.packet.v1.PacketSequence.destination_chain": + x.DestinationChain = value.Interface().(string) + case "tibc.core.packet.v1.PacketSequence.sequence": + x.Sequence = value.Uint() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.PacketSequence")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.PacketSequence 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_PacketSequence) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.PacketSequence.source_chain": + panic(fmt.Errorf("field source_chain of message tibc.core.packet.v1.PacketSequence is not mutable")) + case "tibc.core.packet.v1.PacketSequence.destination_chain": + panic(fmt.Errorf("field destination_chain of message tibc.core.packet.v1.PacketSequence is not mutable")) + case "tibc.core.packet.v1.PacketSequence.sequence": + panic(fmt.Errorf("field sequence of message tibc.core.packet.v1.PacketSequence is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.PacketSequence")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.PacketSequence 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_PacketSequence) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.PacketSequence.source_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.PacketSequence.destination_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.PacketSequence.sequence": + return protoreflect.ValueOfUint64(uint64(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.PacketSequence")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.PacketSequence 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_PacketSequence) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.PacketSequence", 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_PacketSequence) 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_PacketSequence) 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_PacketSequence) 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_PacketSequence) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*PacketSequence) + 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.SourceChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.DestinationChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Sequence != 0 { + n += 1 + runtime.Sov(uint64(x.Sequence)) + } + 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().(*PacketSequence) + 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.Sequence != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Sequence)) + i-- + dAtA[i] = 0x18 + } + if len(x.DestinationChain) > 0 { + i -= len(x.DestinationChain) + copy(dAtA[i:], x.DestinationChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestinationChain))) + i-- + dAtA[i] = 0x12 + } + if len(x.SourceChain) > 0 { + i -= len(x.SourceChain) + copy(dAtA[i:], x.SourceChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SourceChain))) + 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().(*PacketSequence) + 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: PacketSequence: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PacketSequence: 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 SourceChain", 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.SourceChain = 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 DestinationChain", 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.DestinationChain = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType) + } + x.Sequence = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Sequence |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: tibc/core/packet/v1/genesis.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) +) + +// GenesisState defines the tibc channel submodule's genesis state. +type GenesisState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Acknowledgements []*PacketState `protobuf:"bytes,2,rep,name=acknowledgements,proto3" json:"acknowledgements,omitempty"` + Commitments []*PacketState `protobuf:"bytes,3,rep,name=commitments,proto3" json:"commitments,omitempty"` + Receipts []*PacketState `protobuf:"bytes,4,rep,name=receipts,proto3" json:"receipts,omitempty"` + SendSequences []*PacketSequence `protobuf:"bytes,5,rep,name=send_sequences,json=sendSequences,proto3" json:"send_sequences,omitempty"` + RecvSequences []*PacketSequence `protobuf:"bytes,6,rep,name=recv_sequences,json=recvSequences,proto3" json:"recv_sequences,omitempty"` + AckSequences []*PacketSequence `protobuf:"bytes,7,rep,name=ack_sequences,json=ackSequences,proto3" json:"ack_sequences,omitempty"` +} + +func (x *GenesisState) Reset() { + *x = GenesisState{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_genesis_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GenesisState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GenesisState) ProtoMessage() {} + +// Deprecated: Use GenesisState.ProtoReflect.Descriptor instead. +func (*GenesisState) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_genesis_proto_rawDescGZIP(), []int{0} +} + +func (x *GenesisState) GetAcknowledgements() []*PacketState { + if x != nil { + return x.Acknowledgements + } + return nil +} + +func (x *GenesisState) GetCommitments() []*PacketState { + if x != nil { + return x.Commitments + } + return nil +} + +func (x *GenesisState) GetReceipts() []*PacketState { + if x != nil { + return x.Receipts + } + return nil +} + +func (x *GenesisState) GetSendSequences() []*PacketSequence { + if x != nil { + return x.SendSequences + } + return nil +} + +func (x *GenesisState) GetRecvSequences() []*PacketSequence { + if x != nil { + return x.RecvSequences + } + return nil +} + +func (x *GenesisState) GetAckSequences() []*PacketSequence { + if x != nil { + return x.AckSequences + } + return nil +} + +// PacketSequence defines the genesis type necessary to retrieve and store +// next send and receive sequences. +type PacketSequence struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + SourceChain string `protobuf:"bytes,1,opt,name=source_chain,json=sourceChain,proto3" json:"source_chain,omitempty"` + DestinationChain string `protobuf:"bytes,2,opt,name=destination_chain,json=destinationChain,proto3" json:"destination_chain,omitempty"` + Sequence uint64 `protobuf:"varint,3,opt,name=sequence,proto3" json:"sequence,omitempty"` +} + +func (x *PacketSequence) Reset() { + *x = PacketSequence{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_genesis_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PacketSequence) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PacketSequence) ProtoMessage() {} + +// Deprecated: Use PacketSequence.ProtoReflect.Descriptor instead. +func (*PacketSequence) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_genesis_proto_rawDescGZIP(), []int{1} +} + +func (x *PacketSequence) GetSourceChain() string { + if x != nil { + return x.SourceChain + } + return "" +} + +func (x *PacketSequence) GetDestinationChain() string { + if x != nil { + return x.DestinationChain + } + return "" +} + +func (x *PacketSequence) GetSequence() uint64 { + if x != nil { + return x.Sequence + } + return 0 +} + +var File_tibc_core_packet_v1_genesis_proto protoreflect.FileDescriptor + +var file_tibc_core_packet_v1_genesis_proto_rawDesc = []byte{ + 0x0a, 0x21, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x70, 0x61, 0x63, 0x6b, + 0x65, 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x13, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, + 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, + 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x22, 0xae, 0x04, 0x0a, 0x0c, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x12, 0x52, 0x0a, 0x10, 0x61, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, + 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x74, 0x69, + 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, + 0x31, 0x2e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x42, 0x04, 0xc8, + 0xde, 0x1f, 0x00, 0x52, 0x10, 0x61, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, + 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x48, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, + 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x74, 0x69, 0x62, + 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, + 0x2e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x42, 0x04, 0xc8, 0xde, + 0x1f, 0x00, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, + 0x42, 0x0a, 0x08, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x20, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, + 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x74, + 0x61, 0x74, 0x65, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x08, 0x72, 0x65, 0x63, 0x65, 0x69, + 0x70, 0x74, 0x73, 0x12, 0x69, 0x0a, 0x0e, 0x73, 0x65, 0x6e, 0x64, 0x5f, 0x73, 0x65, 0x71, 0x75, + 0x65, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x74, 0x69, + 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, + 0x31, 0x2e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, + 0x42, 0x1d, 0xc8, 0xde, 0x1f, 0x00, 0xf2, 0xde, 0x1f, 0x15, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, + 0x73, 0x65, 0x6e, 0x64, 0x5f, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x22, 0x52, + 0x0d, 0x73, 0x65, 0x6e, 0x64, 0x53, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x69, + 0x0a, 0x0e, 0x72, 0x65, 0x63, 0x76, 0x5f, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, + 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x63, + 0x6b, 0x65, 0x74, 0x53, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x42, 0x1d, 0xc8, 0xde, 0x1f, + 0x00, 0xf2, 0xde, 0x1f, 0x15, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x72, 0x65, 0x63, 0x76, 0x5f, + 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x22, 0x52, 0x0d, 0x72, 0x65, 0x63, 0x76, + 0x53, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x66, 0x0a, 0x0d, 0x61, 0x63, 0x6b, + 0x5f, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x23, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, + 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x65, 0x71, + 0x75, 0x65, 0x6e, 0x63, 0x65, 0x42, 0x1c, 0xc8, 0xde, 0x1f, 0x00, 0xf2, 0xde, 0x1f, 0x14, 0x79, + 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x61, 0x63, 0x6b, 0x5f, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, + 0x65, 0x73, 0x22, 0x52, 0x0c, 0x61, 0x63, 0x6b, 0x53, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, + 0x73, 0x22, 0xb3, 0x01, 0x0a, 0x0e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x65, 0x71, 0x75, + 0x65, 0x6e, 0x63, 0x65, 0x12, 0x3a, 0x0a, 0x0c, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, + 0x68, 0x61, 0x69, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x17, 0xf2, 0xde, 0x1f, 0x13, + 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, + 0x69, 0x6e, 0x22, 0x52, 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x68, 0x61, 0x69, 0x6e, + 0x12, 0x49, 0x0a, 0x11, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x1c, 0xf2, 0xde, 0x1f, + 0x18, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x22, 0x52, 0x10, 0x64, 0x65, 0x73, 0x74, 0x69, + 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x73, + 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x73, + 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x42, 0xd5, 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, + 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, + 0x2e, 0x76, 0x31, 0x42, 0x0c, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x50, 0x72, 0x6f, 0x74, + 0x6f, 0x50, 0x01, 0x5a, 0x3d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, + 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2d, 0x67, + 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, + 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2f, 0x76, 0x31, 0x3b, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, + 0x76, 0x31, 0xa2, 0x02, 0x03, 0x54, 0x43, 0x50, 0xaa, 0x02, 0x13, 0x54, 0x69, 0x62, 0x63, 0x2e, + 0x43, 0x6f, 0x72, 0x65, 0x2e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x56, 0x31, 0xca, 0x02, + 0x13, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x50, 0x61, 0x63, 0x6b, 0x65, + 0x74, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x1f, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x43, 0x6f, 0x72, 0x65, + 0x5c, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x16, 0x54, 0x69, 0x62, 0x63, 0x3a, 0x3a, 0x43, + 0x6f, 0x72, 0x65, 0x3a, 0x3a, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x3a, 0x3a, 0x56, 0x31, 0x62, + 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_core_packet_v1_genesis_proto_rawDescOnce sync.Once + file_tibc_core_packet_v1_genesis_proto_rawDescData = file_tibc_core_packet_v1_genesis_proto_rawDesc +) + +func file_tibc_core_packet_v1_genesis_proto_rawDescGZIP() []byte { + file_tibc_core_packet_v1_genesis_proto_rawDescOnce.Do(func() { + file_tibc_core_packet_v1_genesis_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_core_packet_v1_genesis_proto_rawDescData) + }) + return file_tibc_core_packet_v1_genesis_proto_rawDescData +} + +var file_tibc_core_packet_v1_genesis_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_tibc_core_packet_v1_genesis_proto_goTypes = []interface{}{ + (*GenesisState)(nil), // 0: tibc.core.packet.v1.GenesisState + (*PacketSequence)(nil), // 1: tibc.core.packet.v1.PacketSequence + (*PacketState)(nil), // 2: tibc.core.packet.v1.PacketState +} +var file_tibc_core_packet_v1_genesis_proto_depIdxs = []int32{ + 2, // 0: tibc.core.packet.v1.GenesisState.acknowledgements:type_name -> tibc.core.packet.v1.PacketState + 2, // 1: tibc.core.packet.v1.GenesisState.commitments:type_name -> tibc.core.packet.v1.PacketState + 2, // 2: tibc.core.packet.v1.GenesisState.receipts:type_name -> tibc.core.packet.v1.PacketState + 1, // 3: tibc.core.packet.v1.GenesisState.send_sequences:type_name -> tibc.core.packet.v1.PacketSequence + 1, // 4: tibc.core.packet.v1.GenesisState.recv_sequences:type_name -> tibc.core.packet.v1.PacketSequence + 1, // 5: tibc.core.packet.v1.GenesisState.ack_sequences:type_name -> tibc.core.packet.v1.PacketSequence + 6, // [6:6] is the sub-list for method output_type + 6, // [6:6] is the sub-list for method input_type + 6, // [6:6] is the sub-list for extension type_name + 6, // [6:6] is the sub-list for extension extendee + 0, // [0:6] is the sub-list for field type_name +} + +func init() { file_tibc_core_packet_v1_genesis_proto_init() } +func file_tibc_core_packet_v1_genesis_proto_init() { + if File_tibc_core_packet_v1_genesis_proto != nil { + return + } + file_tibc_core_packet_v1_packet_proto_init() + if !protoimpl.UnsafeEnabled { + file_tibc_core_packet_v1_genesis_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GenesisState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_genesis_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PacketSequence); 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_tibc_core_packet_v1_genesis_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_tibc_core_packet_v1_genesis_proto_goTypes, + DependencyIndexes: file_tibc_core_packet_v1_genesis_proto_depIdxs, + MessageInfos: file_tibc_core_packet_v1_genesis_proto_msgTypes, + }.Build() + File_tibc_core_packet_v1_genesis_proto = out.File + file_tibc_core_packet_v1_genesis_proto_rawDesc = nil + file_tibc_core_packet_v1_genesis_proto_goTypes = nil + file_tibc_core_packet_v1_genesis_proto_depIdxs = nil +} diff --git a/api/tibc/core/packet/v1/packet.pulsar.go b/api/tibc/core/packet/v1/packet.pulsar.go new file mode 100644 index 00000000..1d35b06d --- /dev/null +++ b/api/tibc/core/packet/v1/packet.pulsar.go @@ -0,0 +1,2956 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package packetv1 + +import ( + fmt "fmt" + 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" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_Packet protoreflect.MessageDescriptor + fd_Packet_sequence protoreflect.FieldDescriptor + fd_Packet_port protoreflect.FieldDescriptor + fd_Packet_source_chain protoreflect.FieldDescriptor + fd_Packet_destination_chain protoreflect.FieldDescriptor + fd_Packet_relay_chain protoreflect.FieldDescriptor + fd_Packet_data protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_packet_proto_init() + md_Packet = File_tibc_core_packet_v1_packet_proto.Messages().ByName("Packet") + fd_Packet_sequence = md_Packet.Fields().ByName("sequence") + fd_Packet_port = md_Packet.Fields().ByName("port") + fd_Packet_source_chain = md_Packet.Fields().ByName("source_chain") + fd_Packet_destination_chain = md_Packet.Fields().ByName("destination_chain") + fd_Packet_relay_chain = md_Packet.Fields().ByName("relay_chain") + fd_Packet_data = md_Packet.Fields().ByName("data") +} + +var _ protoreflect.Message = (*fastReflection_Packet)(nil) + +type fastReflection_Packet Packet + +func (x *Packet) ProtoReflect() protoreflect.Message { + return (*fastReflection_Packet)(x) +} + +func (x *Packet) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_packet_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_Packet_messageType fastReflection_Packet_messageType +var _ protoreflect.MessageType = fastReflection_Packet_messageType{} + +type fastReflection_Packet_messageType struct{} + +func (x fastReflection_Packet_messageType) Zero() protoreflect.Message { + return (*fastReflection_Packet)(nil) +} +func (x fastReflection_Packet_messageType) New() protoreflect.Message { + return new(fastReflection_Packet) +} +func (x fastReflection_Packet_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Packet +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Packet) Descriptor() protoreflect.MessageDescriptor { + return md_Packet +} + +// 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_Packet) Type() protoreflect.MessageType { + return _fastReflection_Packet_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Packet) New() protoreflect.Message { + return new(fastReflection_Packet) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Packet) Interface() protoreflect.ProtoMessage { + return (*Packet)(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_Packet) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Sequence != uint64(0) { + value := protoreflect.ValueOfUint64(x.Sequence) + if !f(fd_Packet_sequence, value) { + return + } + } + if x.Port != "" { + value := protoreflect.ValueOfString(x.Port) + if !f(fd_Packet_port, value) { + return + } + } + if x.SourceChain != "" { + value := protoreflect.ValueOfString(x.SourceChain) + if !f(fd_Packet_source_chain, value) { + return + } + } + if x.DestinationChain != "" { + value := protoreflect.ValueOfString(x.DestinationChain) + if !f(fd_Packet_destination_chain, value) { + return + } + } + if x.RelayChain != "" { + value := protoreflect.ValueOfString(x.RelayChain) + if !f(fd_Packet_relay_chain, value) { + return + } + } + if len(x.Data) != 0 { + value := protoreflect.ValueOfBytes(x.Data) + if !f(fd_Packet_data, 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_Packet) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.Packet.sequence": + return x.Sequence != uint64(0) + case "tibc.core.packet.v1.Packet.port": + return x.Port != "" + case "tibc.core.packet.v1.Packet.source_chain": + return x.SourceChain != "" + case "tibc.core.packet.v1.Packet.destination_chain": + return x.DestinationChain != "" + case "tibc.core.packet.v1.Packet.relay_chain": + return x.RelayChain != "" + case "tibc.core.packet.v1.Packet.data": + return len(x.Data) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.Packet")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.Packet 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_Packet) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.Packet.sequence": + x.Sequence = uint64(0) + case "tibc.core.packet.v1.Packet.port": + x.Port = "" + case "tibc.core.packet.v1.Packet.source_chain": + x.SourceChain = "" + case "tibc.core.packet.v1.Packet.destination_chain": + x.DestinationChain = "" + case "tibc.core.packet.v1.Packet.relay_chain": + x.RelayChain = "" + case "tibc.core.packet.v1.Packet.data": + x.Data = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.Packet")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.Packet 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_Packet) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.Packet.sequence": + value := x.Sequence + return protoreflect.ValueOfUint64(value) + case "tibc.core.packet.v1.Packet.port": + value := x.Port + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.Packet.source_chain": + value := x.SourceChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.Packet.destination_chain": + value := x.DestinationChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.Packet.relay_chain": + value := x.RelayChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.Packet.data": + value := x.Data + return protoreflect.ValueOfBytes(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.Packet")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.Packet 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_Packet) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.Packet.sequence": + x.Sequence = value.Uint() + case "tibc.core.packet.v1.Packet.port": + x.Port = value.Interface().(string) + case "tibc.core.packet.v1.Packet.source_chain": + x.SourceChain = value.Interface().(string) + case "tibc.core.packet.v1.Packet.destination_chain": + x.DestinationChain = value.Interface().(string) + case "tibc.core.packet.v1.Packet.relay_chain": + x.RelayChain = value.Interface().(string) + case "tibc.core.packet.v1.Packet.data": + x.Data = value.Bytes() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.Packet")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.Packet 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_Packet) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.Packet.sequence": + panic(fmt.Errorf("field sequence of message tibc.core.packet.v1.Packet is not mutable")) + case "tibc.core.packet.v1.Packet.port": + panic(fmt.Errorf("field port of message tibc.core.packet.v1.Packet is not mutable")) + case "tibc.core.packet.v1.Packet.source_chain": + panic(fmt.Errorf("field source_chain of message tibc.core.packet.v1.Packet is not mutable")) + case "tibc.core.packet.v1.Packet.destination_chain": + panic(fmt.Errorf("field destination_chain of message tibc.core.packet.v1.Packet is not mutable")) + case "tibc.core.packet.v1.Packet.relay_chain": + panic(fmt.Errorf("field relay_chain of message tibc.core.packet.v1.Packet is not mutable")) + case "tibc.core.packet.v1.Packet.data": + panic(fmt.Errorf("field data of message tibc.core.packet.v1.Packet is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.Packet")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.Packet 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_Packet) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.Packet.sequence": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.core.packet.v1.Packet.port": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.Packet.source_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.Packet.destination_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.Packet.relay_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.Packet.data": + return protoreflect.ValueOfBytes(nil) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.Packet")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.Packet 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_Packet) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.Packet", 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_Packet) 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_Packet) 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_Packet) 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_Packet) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Packet) + 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.Sequence != 0 { + n += 1 + runtime.Sov(uint64(x.Sequence)) + } + l = len(x.Port) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.SourceChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.DestinationChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.RelayChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Data) + 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().(*Packet) + 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.Data) > 0 { + i -= len(x.Data) + copy(dAtA[i:], x.Data) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Data))) + i-- + dAtA[i] = 0x32 + } + if len(x.RelayChain) > 0 { + i -= len(x.RelayChain) + copy(dAtA[i:], x.RelayChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RelayChain))) + i-- + dAtA[i] = 0x2a + } + if len(x.DestinationChain) > 0 { + i -= len(x.DestinationChain) + copy(dAtA[i:], x.DestinationChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestinationChain))) + i-- + dAtA[i] = 0x22 + } + if len(x.SourceChain) > 0 { + i -= len(x.SourceChain) + copy(dAtA[i:], x.SourceChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SourceChain))) + i-- + dAtA[i] = 0x1a + } + if len(x.Port) > 0 { + i -= len(x.Port) + copy(dAtA[i:], x.Port) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Port))) + i-- + dAtA[i] = 0x12 + } + if x.Sequence != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Sequence)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*Packet) + 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: Packet: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Packet: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType) + } + x.Sequence = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Sequence |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Port", 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.Port = 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 SourceChain", 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.SourceChain = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DestinationChain", 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.DestinationChain = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RelayChain", 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.RelayChain = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Data = append(x.Data[:0], dAtA[iNdEx:postIndex]...) + if x.Data == nil { + x.Data = []byte{} + } + 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_CleanPacket protoreflect.MessageDescriptor + fd_CleanPacket_sequence protoreflect.FieldDescriptor + fd_CleanPacket_source_chain protoreflect.FieldDescriptor + fd_CleanPacket_destination_chain protoreflect.FieldDescriptor + fd_CleanPacket_relay_chain protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_packet_proto_init() + md_CleanPacket = File_tibc_core_packet_v1_packet_proto.Messages().ByName("CleanPacket") + fd_CleanPacket_sequence = md_CleanPacket.Fields().ByName("sequence") + fd_CleanPacket_source_chain = md_CleanPacket.Fields().ByName("source_chain") + fd_CleanPacket_destination_chain = md_CleanPacket.Fields().ByName("destination_chain") + fd_CleanPacket_relay_chain = md_CleanPacket.Fields().ByName("relay_chain") +} + +var _ protoreflect.Message = (*fastReflection_CleanPacket)(nil) + +type fastReflection_CleanPacket CleanPacket + +func (x *CleanPacket) ProtoReflect() protoreflect.Message { + return (*fastReflection_CleanPacket)(x) +} + +func (x *CleanPacket) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_packet_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_CleanPacket_messageType fastReflection_CleanPacket_messageType +var _ protoreflect.MessageType = fastReflection_CleanPacket_messageType{} + +type fastReflection_CleanPacket_messageType struct{} + +func (x fastReflection_CleanPacket_messageType) Zero() protoreflect.Message { + return (*fastReflection_CleanPacket)(nil) +} +func (x fastReflection_CleanPacket_messageType) New() protoreflect.Message { + return new(fastReflection_CleanPacket) +} +func (x fastReflection_CleanPacket_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_CleanPacket +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_CleanPacket) Descriptor() protoreflect.MessageDescriptor { + return md_CleanPacket +} + +// 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_CleanPacket) Type() protoreflect.MessageType { + return _fastReflection_CleanPacket_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_CleanPacket) New() protoreflect.Message { + return new(fastReflection_CleanPacket) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_CleanPacket) Interface() protoreflect.ProtoMessage { + return (*CleanPacket)(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_CleanPacket) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Sequence != uint64(0) { + value := protoreflect.ValueOfUint64(x.Sequence) + if !f(fd_CleanPacket_sequence, value) { + return + } + } + if x.SourceChain != "" { + value := protoreflect.ValueOfString(x.SourceChain) + if !f(fd_CleanPacket_source_chain, value) { + return + } + } + if x.DestinationChain != "" { + value := protoreflect.ValueOfString(x.DestinationChain) + if !f(fd_CleanPacket_destination_chain, value) { + return + } + } + if x.RelayChain != "" { + value := protoreflect.ValueOfString(x.RelayChain) + if !f(fd_CleanPacket_relay_chain, 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_CleanPacket) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.CleanPacket.sequence": + return x.Sequence != uint64(0) + case "tibc.core.packet.v1.CleanPacket.source_chain": + return x.SourceChain != "" + case "tibc.core.packet.v1.CleanPacket.destination_chain": + return x.DestinationChain != "" + case "tibc.core.packet.v1.CleanPacket.relay_chain": + return x.RelayChain != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.CleanPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.CleanPacket 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_CleanPacket) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.CleanPacket.sequence": + x.Sequence = uint64(0) + case "tibc.core.packet.v1.CleanPacket.source_chain": + x.SourceChain = "" + case "tibc.core.packet.v1.CleanPacket.destination_chain": + x.DestinationChain = "" + case "tibc.core.packet.v1.CleanPacket.relay_chain": + x.RelayChain = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.CleanPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.CleanPacket 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_CleanPacket) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.CleanPacket.sequence": + value := x.Sequence + return protoreflect.ValueOfUint64(value) + case "tibc.core.packet.v1.CleanPacket.source_chain": + value := x.SourceChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.CleanPacket.destination_chain": + value := x.DestinationChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.CleanPacket.relay_chain": + value := x.RelayChain + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.CleanPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.CleanPacket 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_CleanPacket) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.CleanPacket.sequence": + x.Sequence = value.Uint() + case "tibc.core.packet.v1.CleanPacket.source_chain": + x.SourceChain = value.Interface().(string) + case "tibc.core.packet.v1.CleanPacket.destination_chain": + x.DestinationChain = value.Interface().(string) + case "tibc.core.packet.v1.CleanPacket.relay_chain": + x.RelayChain = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.CleanPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.CleanPacket 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_CleanPacket) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.CleanPacket.sequence": + panic(fmt.Errorf("field sequence of message tibc.core.packet.v1.CleanPacket is not mutable")) + case "tibc.core.packet.v1.CleanPacket.source_chain": + panic(fmt.Errorf("field source_chain of message tibc.core.packet.v1.CleanPacket is not mutable")) + case "tibc.core.packet.v1.CleanPacket.destination_chain": + panic(fmt.Errorf("field destination_chain of message tibc.core.packet.v1.CleanPacket is not mutable")) + case "tibc.core.packet.v1.CleanPacket.relay_chain": + panic(fmt.Errorf("field relay_chain of message tibc.core.packet.v1.CleanPacket is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.CleanPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.CleanPacket 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_CleanPacket) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.CleanPacket.sequence": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.core.packet.v1.CleanPacket.source_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.CleanPacket.destination_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.CleanPacket.relay_chain": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.CleanPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.CleanPacket 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_CleanPacket) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.CleanPacket", 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_CleanPacket) 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_CleanPacket) 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_CleanPacket) 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_CleanPacket) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*CleanPacket) + 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.Sequence != 0 { + n += 1 + runtime.Sov(uint64(x.Sequence)) + } + l = len(x.SourceChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.DestinationChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.RelayChain) + 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().(*CleanPacket) + 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.RelayChain) > 0 { + i -= len(x.RelayChain) + copy(dAtA[i:], x.RelayChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RelayChain))) + i-- + dAtA[i] = 0x2a + } + if len(x.DestinationChain) > 0 { + i -= len(x.DestinationChain) + copy(dAtA[i:], x.DestinationChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestinationChain))) + i-- + dAtA[i] = 0x22 + } + if len(x.SourceChain) > 0 { + i -= len(x.SourceChain) + copy(dAtA[i:], x.SourceChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SourceChain))) + i-- + dAtA[i] = 0x1a + } + if x.Sequence != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Sequence)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*CleanPacket) + 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: CleanPacket: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: CleanPacket: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType) + } + x.Sequence = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Sequence |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SourceChain", 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.SourceChain = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DestinationChain", 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.DestinationChain = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RelayChain", 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.RelayChain = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_PacketState protoreflect.MessageDescriptor + fd_PacketState_source_chain protoreflect.FieldDescriptor + fd_PacketState_destination_chain protoreflect.FieldDescriptor + fd_PacketState_sequence protoreflect.FieldDescriptor + fd_PacketState_data protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_packet_proto_init() + md_PacketState = File_tibc_core_packet_v1_packet_proto.Messages().ByName("PacketState") + fd_PacketState_source_chain = md_PacketState.Fields().ByName("source_chain") + fd_PacketState_destination_chain = md_PacketState.Fields().ByName("destination_chain") + fd_PacketState_sequence = md_PacketState.Fields().ByName("sequence") + fd_PacketState_data = md_PacketState.Fields().ByName("data") +} + +var _ protoreflect.Message = (*fastReflection_PacketState)(nil) + +type fastReflection_PacketState PacketState + +func (x *PacketState) ProtoReflect() protoreflect.Message { + return (*fastReflection_PacketState)(x) +} + +func (x *PacketState) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_packet_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_PacketState_messageType fastReflection_PacketState_messageType +var _ protoreflect.MessageType = fastReflection_PacketState_messageType{} + +type fastReflection_PacketState_messageType struct{} + +func (x fastReflection_PacketState_messageType) Zero() protoreflect.Message { + return (*fastReflection_PacketState)(nil) +} +func (x fastReflection_PacketState_messageType) New() protoreflect.Message { + return new(fastReflection_PacketState) +} +func (x fastReflection_PacketState_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_PacketState +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_PacketState) Descriptor() protoreflect.MessageDescriptor { + return md_PacketState +} + +// 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_PacketState) Type() protoreflect.MessageType { + return _fastReflection_PacketState_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_PacketState) New() protoreflect.Message { + return new(fastReflection_PacketState) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_PacketState) Interface() protoreflect.ProtoMessage { + return (*PacketState)(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_PacketState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.SourceChain != "" { + value := protoreflect.ValueOfString(x.SourceChain) + if !f(fd_PacketState_source_chain, value) { + return + } + } + if x.DestinationChain != "" { + value := protoreflect.ValueOfString(x.DestinationChain) + if !f(fd_PacketState_destination_chain, value) { + return + } + } + if x.Sequence != uint64(0) { + value := protoreflect.ValueOfUint64(x.Sequence) + if !f(fd_PacketState_sequence, value) { + return + } + } + if len(x.Data) != 0 { + value := protoreflect.ValueOfBytes(x.Data) + if !f(fd_PacketState_data, 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_PacketState) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.PacketState.source_chain": + return x.SourceChain != "" + case "tibc.core.packet.v1.PacketState.destination_chain": + return x.DestinationChain != "" + case "tibc.core.packet.v1.PacketState.sequence": + return x.Sequence != uint64(0) + case "tibc.core.packet.v1.PacketState.data": + return len(x.Data) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.PacketState")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.PacketState 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_PacketState) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.PacketState.source_chain": + x.SourceChain = "" + case "tibc.core.packet.v1.PacketState.destination_chain": + x.DestinationChain = "" + case "tibc.core.packet.v1.PacketState.sequence": + x.Sequence = uint64(0) + case "tibc.core.packet.v1.PacketState.data": + x.Data = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.PacketState")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.PacketState 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_PacketState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.PacketState.source_chain": + value := x.SourceChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.PacketState.destination_chain": + value := x.DestinationChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.PacketState.sequence": + value := x.Sequence + return protoreflect.ValueOfUint64(value) + case "tibc.core.packet.v1.PacketState.data": + value := x.Data + return protoreflect.ValueOfBytes(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.PacketState")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.PacketState 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_PacketState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.PacketState.source_chain": + x.SourceChain = value.Interface().(string) + case "tibc.core.packet.v1.PacketState.destination_chain": + x.DestinationChain = value.Interface().(string) + case "tibc.core.packet.v1.PacketState.sequence": + x.Sequence = value.Uint() + case "tibc.core.packet.v1.PacketState.data": + x.Data = value.Bytes() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.PacketState")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.PacketState 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_PacketState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.PacketState.source_chain": + panic(fmt.Errorf("field source_chain of message tibc.core.packet.v1.PacketState is not mutable")) + case "tibc.core.packet.v1.PacketState.destination_chain": + panic(fmt.Errorf("field destination_chain of message tibc.core.packet.v1.PacketState is not mutable")) + case "tibc.core.packet.v1.PacketState.sequence": + panic(fmt.Errorf("field sequence of message tibc.core.packet.v1.PacketState is not mutable")) + case "tibc.core.packet.v1.PacketState.data": + panic(fmt.Errorf("field data of message tibc.core.packet.v1.PacketState is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.PacketState")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.PacketState 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_PacketState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.PacketState.source_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.PacketState.destination_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.PacketState.sequence": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.core.packet.v1.PacketState.data": + return protoreflect.ValueOfBytes(nil) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.PacketState")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.PacketState 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_PacketState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.PacketState", 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_PacketState) 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_PacketState) 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_PacketState) 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_PacketState) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*PacketState) + 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.SourceChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.DestinationChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Sequence != 0 { + n += 1 + runtime.Sov(uint64(x.Sequence)) + } + l = len(x.Data) + 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().(*PacketState) + 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.Data) > 0 { + i -= len(x.Data) + copy(dAtA[i:], x.Data) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Data))) + i-- + dAtA[i] = 0x22 + } + if x.Sequence != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Sequence)) + i-- + dAtA[i] = 0x18 + } + if len(x.DestinationChain) > 0 { + i -= len(x.DestinationChain) + copy(dAtA[i:], x.DestinationChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestinationChain))) + i-- + dAtA[i] = 0x12 + } + if len(x.SourceChain) > 0 { + i -= len(x.SourceChain) + copy(dAtA[i:], x.SourceChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SourceChain))) + 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().(*PacketState) + 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: PacketState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PacketState: 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 SourceChain", 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.SourceChain = 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 DestinationChain", 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.DestinationChain = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType) + } + x.Sequence = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Sequence |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Data = append(x.Data[:0], dAtA[iNdEx:postIndex]...) + if x.Data == nil { + x.Data = []byte{} + } + 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_Acknowledgement protoreflect.MessageDescriptor + fd_Acknowledgement_result protoreflect.FieldDescriptor + fd_Acknowledgement_error protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_packet_proto_init() + md_Acknowledgement = File_tibc_core_packet_v1_packet_proto.Messages().ByName("Acknowledgement") + fd_Acknowledgement_result = md_Acknowledgement.Fields().ByName("result") + fd_Acknowledgement_error = md_Acknowledgement.Fields().ByName("error") +} + +var _ protoreflect.Message = (*fastReflection_Acknowledgement)(nil) + +type fastReflection_Acknowledgement Acknowledgement + +func (x *Acknowledgement) ProtoReflect() protoreflect.Message { + return (*fastReflection_Acknowledgement)(x) +} + +func (x *Acknowledgement) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_packet_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_Acknowledgement_messageType fastReflection_Acknowledgement_messageType +var _ protoreflect.MessageType = fastReflection_Acknowledgement_messageType{} + +type fastReflection_Acknowledgement_messageType struct{} + +func (x fastReflection_Acknowledgement_messageType) Zero() protoreflect.Message { + return (*fastReflection_Acknowledgement)(nil) +} +func (x fastReflection_Acknowledgement_messageType) New() protoreflect.Message { + return new(fastReflection_Acknowledgement) +} +func (x fastReflection_Acknowledgement_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Acknowledgement +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Acknowledgement) Descriptor() protoreflect.MessageDescriptor { + return md_Acknowledgement +} + +// 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_Acknowledgement) Type() protoreflect.MessageType { + return _fastReflection_Acknowledgement_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Acknowledgement) New() protoreflect.Message { + return new(fastReflection_Acknowledgement) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Acknowledgement) Interface() protoreflect.ProtoMessage { + return (*Acknowledgement)(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_Acknowledgement) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Response != nil { + switch o := x.Response.(type) { + case *Acknowledgement_Result: + v := o.Result + value := protoreflect.ValueOfBytes(v) + if !f(fd_Acknowledgement_result, value) { + return + } + case *Acknowledgement_Error: + v := o.Error + value := protoreflect.ValueOfString(v) + if !f(fd_Acknowledgement_error, 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_Acknowledgement) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.Acknowledgement.result": + if x.Response == nil { + return false + } else if _, ok := x.Response.(*Acknowledgement_Result); ok { + return true + } else { + return false + } + case "tibc.core.packet.v1.Acknowledgement.error": + if x.Response == nil { + return false + } else if _, ok := x.Response.(*Acknowledgement_Error); ok { + return true + } else { + return false + } + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.Acknowledgement")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.Acknowledgement 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_Acknowledgement) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.Acknowledgement.result": + x.Response = nil + case "tibc.core.packet.v1.Acknowledgement.error": + x.Response = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.Acknowledgement")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.Acknowledgement 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_Acknowledgement) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.Acknowledgement.result": + if x.Response == nil { + return protoreflect.ValueOfBytes(nil) + } else if v, ok := x.Response.(*Acknowledgement_Result); ok { + return protoreflect.ValueOfBytes(v.Result) + } else { + return protoreflect.ValueOfBytes(nil) + } + case "tibc.core.packet.v1.Acknowledgement.error": + if x.Response == nil { + return protoreflect.ValueOfString("") + } else if v, ok := x.Response.(*Acknowledgement_Error); ok { + return protoreflect.ValueOfString(v.Error) + } else { + return protoreflect.ValueOfString("") + } + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.Acknowledgement")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.Acknowledgement 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_Acknowledgement) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.Acknowledgement.result": + cv := value.Bytes() + x.Response = &Acknowledgement_Result{Result: cv} + case "tibc.core.packet.v1.Acknowledgement.error": + cv := value.Interface().(string) + x.Response = &Acknowledgement_Error{Error: cv} + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.Acknowledgement")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.Acknowledgement 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_Acknowledgement) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.Acknowledgement.result": + panic(fmt.Errorf("field result of message tibc.core.packet.v1.Acknowledgement is not mutable")) + case "tibc.core.packet.v1.Acknowledgement.error": + panic(fmt.Errorf("field error of message tibc.core.packet.v1.Acknowledgement is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.Acknowledgement")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.Acknowledgement 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_Acknowledgement) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.Acknowledgement.result": + return protoreflect.ValueOfBytes(nil) + case "tibc.core.packet.v1.Acknowledgement.error": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.Acknowledgement")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.Acknowledgement 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_Acknowledgement) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + case "tibc.core.packet.v1.Acknowledgement.response": + if x.Response == nil { + return nil + } + switch x.Response.(type) { + case *Acknowledgement_Result: + return x.Descriptor().Fields().ByName("result") + case *Acknowledgement_Error: + return x.Descriptor().Fields().ByName("error") + } + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.Acknowledgement", 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_Acknowledgement) 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_Acknowledgement) 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_Acknowledgement) 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_Acknowledgement) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Acknowledgement) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + switch x := x.Response.(type) { + case *Acknowledgement_Result: + if x == nil { + break + } + l = len(x.Result) + n += 2 + l + runtime.Sov(uint64(l)) + case *Acknowledgement_Error: + if x == nil { + break + } + l = len(x.Error) + n += 2 + 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().(*Acknowledgement) + 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) + } + switch x := x.Response.(type) { + case *Acknowledgement_Result: + i -= len(x.Result) + copy(dAtA[i:], x.Result) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Result))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xaa + case *Acknowledgement_Error: + i -= len(x.Error) + copy(dAtA[i:], x.Error) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Error))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xb2 + } + 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().(*Acknowledgement) + 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: Acknowledgement: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Acknowledgement: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 21: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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 + } + v := make([]byte, postIndex-iNdEx) + copy(v, dAtA[iNdEx:postIndex]) + x.Response = &Acknowledgement_Result{v} + iNdEx = postIndex + case 22: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Response = &Acknowledgement_Error{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, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: tibc/core/packet/v1/packet.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) +) + +// Packet defines a type that carries data across different chains through TIBC +type Packet struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // number corresponds to the order of sends and receives, where a Packet + // with an earlier sequence number must be sent and received before a Packet + // with a later sequence number. + Sequence uint64 `protobuf:"varint,1,opt,name=sequence,proto3" json:"sequence,omitempty"` + // identifies the port on the sending chain and destination chain. + Port string `protobuf:"bytes,2,opt,name=port,proto3" json:"port,omitempty"` + // identifies the chain id of the sending chain. + SourceChain string `protobuf:"bytes,3,opt,name=source_chain,json=sourceChain,proto3" json:"source_chain,omitempty"` + // identifies the chain id of the receiving chain. + DestinationChain string `protobuf:"bytes,4,opt,name=destination_chain,json=destinationChain,proto3" json:"destination_chain,omitempty"` + // identifies the chain id of the relay chain. + RelayChain string `protobuf:"bytes,5,opt,name=relay_chain,json=relayChain,proto3" json:"relay_chain,omitempty"` + // actual opaque bytes transferred directly to the application module + Data []byte `protobuf:"bytes,6,opt,name=data,proto3" json:"data,omitempty"` +} + +func (x *Packet) Reset() { + *x = Packet{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_packet_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Packet) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Packet) ProtoMessage() {} + +// Deprecated: Use Packet.ProtoReflect.Descriptor instead. +func (*Packet) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_packet_proto_rawDescGZIP(), []int{0} +} + +func (x *Packet) GetSequence() uint64 { + if x != nil { + return x.Sequence + } + return 0 +} + +func (x *Packet) GetPort() string { + if x != nil { + return x.Port + } + return "" +} + +func (x *Packet) GetSourceChain() string { + if x != nil { + return x.SourceChain + } + return "" +} + +func (x *Packet) GetDestinationChain() string { + if x != nil { + return x.DestinationChain + } + return "" +} + +func (x *Packet) GetRelayChain() string { + if x != nil { + return x.RelayChain + } + return "" +} + +func (x *Packet) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +// CleanPacket defines a type that carries data across different chains through +// TIBC +type CleanPacket struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // number corresponds to the order of sends and receives, where a Packet + // with an earlier sequence number must be sent and received before a Packet + // with a later sequence number. + Sequence uint64 `protobuf:"varint,1,opt,name=sequence,proto3" json:"sequence,omitempty"` + // identifies the chain id of the sending chain. + SourceChain string `protobuf:"bytes,3,opt,name=source_chain,json=sourceChain,proto3" json:"source_chain,omitempty"` + // identifies the chain id of the receiving chain. + DestinationChain string `protobuf:"bytes,4,opt,name=destination_chain,json=destinationChain,proto3" json:"destination_chain,omitempty"` + // identifies the chain id of the relay chain. + RelayChain string `protobuf:"bytes,5,opt,name=relay_chain,json=relayChain,proto3" json:"relay_chain,omitempty"` +} + +func (x *CleanPacket) Reset() { + *x = CleanPacket{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_packet_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CleanPacket) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CleanPacket) ProtoMessage() {} + +// Deprecated: Use CleanPacket.ProtoReflect.Descriptor instead. +func (*CleanPacket) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_packet_proto_rawDescGZIP(), []int{1} +} + +func (x *CleanPacket) GetSequence() uint64 { + if x != nil { + return x.Sequence + } + return 0 +} + +func (x *CleanPacket) GetSourceChain() string { + if x != nil { + return x.SourceChain + } + return "" +} + +func (x *CleanPacket) GetDestinationChain() string { + if x != nil { + return x.DestinationChain + } + return "" +} + +func (x *CleanPacket) GetRelayChain() string { + if x != nil { + return x.RelayChain + } + return "" +} + +// PacketState defines the generic type necessary to retrieve and store +// packet commitments, acknowledgements, and receipts. +// Caller is responsible for knowing the context necessary to interpret this +// state as a commitment, acknowledgement, or a receipt. +type PacketState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // the sending chain identifier. + SourceChain string `protobuf:"bytes,1,opt,name=source_chain,json=sourceChain,proto3" json:"source_chain,omitempty"` + // the receiving chain identifier. + DestinationChain string `protobuf:"bytes,2,opt,name=destination_chain,json=destinationChain,proto3" json:"destination_chain,omitempty"` + // packet sequence. + Sequence uint64 `protobuf:"varint,3,opt,name=sequence,proto3" json:"sequence,omitempty"` + // embedded data that represents packet state. + Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"` +} + +func (x *PacketState) Reset() { + *x = PacketState{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_packet_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PacketState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PacketState) ProtoMessage() {} + +// Deprecated: Use PacketState.ProtoReflect.Descriptor instead. +func (*PacketState) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_packet_proto_rawDescGZIP(), []int{2} +} + +func (x *PacketState) GetSourceChain() string { + if x != nil { + return x.SourceChain + } + return "" +} + +func (x *PacketState) GetDestinationChain() string { + if x != nil { + return x.DestinationChain + } + return "" +} + +func (x *PacketState) GetSequence() uint64 { + if x != nil { + return x.Sequence + } + return 0 +} + +func (x *PacketState) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +// Acknowledgement is the recommended acknowledgement format to be used by +// app-specific protocols. +// NOTE: The field numbers 21 and 22 were explicitly chosen to avoid accidental +// conflicts with other protobuf message formats used for acknowledgements. +// The first byte of any message with this format will be the non-ASCII values +// `0xaa` (result) or `0xb2` (error). Implemented as defined by TICS: +// https://github.com/bianjieai/tics/tree/master/spec/tics-004-channel-and-packet-semantics#acknowledgement-envelope +type Acknowledgement struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // response contains either a result or an error and must be non-empty + // + // Types that are assignable to Response: + // + // *Acknowledgement_Result + // *Acknowledgement_Error + Response isAcknowledgement_Response `protobuf_oneof:"response"` +} + +func (x *Acknowledgement) Reset() { + *x = Acknowledgement{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_packet_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Acknowledgement) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Acknowledgement) ProtoMessage() {} + +// Deprecated: Use Acknowledgement.ProtoReflect.Descriptor instead. +func (*Acknowledgement) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_packet_proto_rawDescGZIP(), []int{3} +} + +func (x *Acknowledgement) GetResponse() isAcknowledgement_Response { + if x != nil { + return x.Response + } + return nil +} + +func (x *Acknowledgement) GetResult() []byte { + if x, ok := x.GetResponse().(*Acknowledgement_Result); ok { + return x.Result + } + return nil +} + +func (x *Acknowledgement) GetError() string { + if x, ok := x.GetResponse().(*Acknowledgement_Error); ok { + return x.Error + } + return "" +} + +type isAcknowledgement_Response interface { + isAcknowledgement_Response() +} + +type Acknowledgement_Result struct { + Result []byte `protobuf:"bytes,21,opt,name=result,proto3,oneof"` +} + +type Acknowledgement_Error struct { + Error string `protobuf:"bytes,22,opt,name=error,proto3,oneof"` +} + +func (*Acknowledgement_Result) isAcknowledgement_Response() {} + +func (*Acknowledgement_Error) isAcknowledgement_Response() {} + +var File_tibc_core_packet_v1_packet_proto protoreflect.FileDescriptor + +var file_tibc_core_packet_v1_packet_proto_rawDesc = []byte{ + 0x0a, 0x20, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x70, 0x61, 0x63, 0x6b, + 0x65, 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x12, 0x13, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, + 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x91, 0x02, + 0x0a, 0x06, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x71, 0x75, + 0x65, 0x6e, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x73, 0x65, 0x71, 0x75, + 0x65, 0x6e, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x12, 0x3a, 0x0a, 0x0c, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x17, + 0xf2, 0xde, 0x1f, 0x13, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x22, 0x52, 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, + 0x68, 0x61, 0x69, 0x6e, 0x12, 0x48, 0x0a, 0x11, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, + 0x1b, 0xf2, 0xde, 0x1f, 0x17, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x64, 0x65, 0x73, 0x74, 0x69, + 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x6f, 0x72, 0x74, 0x22, 0x52, 0x10, 0x64, 0x65, + 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x37, + 0x0a, 0x0b, 0x72, 0x65, 0x6c, 0x61, 0x79, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x09, 0x42, 0x16, 0xf2, 0xde, 0x1f, 0x12, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x72, + 0x65, 0x6c, 0x61, 0x79, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x22, 0x52, 0x0a, 0x72, 0x65, 0x6c, + 0x61, 0x79, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x3a, 0x04, 0x88, 0xa0, 0x1f, + 0x00, 0x22, 0xee, 0x01, 0x0a, 0x0b, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x50, 0x61, 0x63, 0x6b, 0x65, + 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x04, 0x52, 0x08, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x3a, 0x0a, + 0x0c, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x42, 0x17, 0xf2, 0xde, 0x1f, 0x13, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x22, 0x52, 0x0b, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x48, 0x0a, 0x11, 0x64, 0x65, 0x73, + 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x42, 0x1b, 0xf2, 0xde, 0x1f, 0x17, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, + 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x6f, 0x72, 0x74, + 0x22, 0x52, 0x10, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x68, + 0x61, 0x69, 0x6e, 0x12, 0x37, 0x0a, 0x0b, 0x72, 0x65, 0x6c, 0x61, 0x79, 0x5f, 0x63, 0x68, 0x61, + 0x69, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x42, 0x16, 0xf2, 0xde, 0x1f, 0x12, 0x79, 0x61, + 0x6d, 0x6c, 0x3a, 0x22, 0x72, 0x65, 0x6c, 0x61, 0x79, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x22, + 0x52, 0x0a, 0x72, 0x65, 0x6c, 0x61, 0x79, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x3a, 0x04, 0x88, 0xa0, + 0x1f, 0x00, 0x22, 0xc5, 0x01, 0x0a, 0x0b, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x74, 0x61, + 0x74, 0x65, 0x12, 0x3a, 0x0a, 0x0c, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, + 0x69, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x17, 0xf2, 0xde, 0x1f, 0x13, 0x79, 0x61, + 0x6d, 0x6c, 0x3a, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, + 0x22, 0x52, 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x44, + 0x0a, 0x11, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x68, + 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x17, 0xf2, 0xde, 0x1f, 0x13, 0x79, + 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, + 0x6e, 0x22, 0x52, 0x10, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x43, + 0x68, 0x61, 0x69, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, + 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, + 0x64, 0x61, 0x74, 0x61, 0x3a, 0x04, 0x88, 0xa0, 0x1f, 0x00, 0x22, 0x4f, 0x0a, 0x0f, 0x41, 0x63, + 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x18, 0x0a, + 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, + 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x16, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, + 0x18, 0x16, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x42, + 0x0a, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0xd4, 0x01, 0x0a, 0x17, + 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, + 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x42, 0x0b, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, + 0x63, 0x2d, 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, + 0x72, 0x65, 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2f, 0x76, 0x31, 0x3b, 0x70, 0x61, 0x63, + 0x6b, 0x65, 0x74, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x54, 0x43, 0x50, 0xaa, 0x02, 0x13, 0x54, 0x69, + 0x62, 0x63, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0x2e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x56, + 0x31, 0xca, 0x02, 0x13, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x50, 0x61, + 0x63, 0x6b, 0x65, 0x74, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x1f, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x43, + 0x6f, 0x72, 0x65, 0x5c, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, + 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x16, 0x54, 0x69, 0x62, 0x63, + 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x3a, 0x3a, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x3a, 0x3a, + 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_core_packet_v1_packet_proto_rawDescOnce sync.Once + file_tibc_core_packet_v1_packet_proto_rawDescData = file_tibc_core_packet_v1_packet_proto_rawDesc +) + +func file_tibc_core_packet_v1_packet_proto_rawDescGZIP() []byte { + file_tibc_core_packet_v1_packet_proto_rawDescOnce.Do(func() { + file_tibc_core_packet_v1_packet_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_core_packet_v1_packet_proto_rawDescData) + }) + return file_tibc_core_packet_v1_packet_proto_rawDescData +} + +var file_tibc_core_packet_v1_packet_proto_msgTypes = make([]protoimpl.MessageInfo, 4) +var file_tibc_core_packet_v1_packet_proto_goTypes = []interface{}{ + (*Packet)(nil), // 0: tibc.core.packet.v1.Packet + (*CleanPacket)(nil), // 1: tibc.core.packet.v1.CleanPacket + (*PacketState)(nil), // 2: tibc.core.packet.v1.PacketState + (*Acknowledgement)(nil), // 3: tibc.core.packet.v1.Acknowledgement +} +var file_tibc_core_packet_v1_packet_proto_depIdxs = []int32{ + 0, // [0:0] is the sub-list for method output_type + 0, // [0:0] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_tibc_core_packet_v1_packet_proto_init() } +func file_tibc_core_packet_v1_packet_proto_init() { + if File_tibc_core_packet_v1_packet_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_tibc_core_packet_v1_packet_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Packet); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_packet_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CleanPacket); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_packet_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PacketState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_packet_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Acknowledgement); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_tibc_core_packet_v1_packet_proto_msgTypes[3].OneofWrappers = []interface{}{ + (*Acknowledgement_Result)(nil), + (*Acknowledgement_Error)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_tibc_core_packet_v1_packet_proto_rawDesc, + NumEnums: 0, + NumMessages: 4, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_tibc_core_packet_v1_packet_proto_goTypes, + DependencyIndexes: file_tibc_core_packet_v1_packet_proto_depIdxs, + MessageInfos: file_tibc_core_packet_v1_packet_proto_msgTypes, + }.Build() + File_tibc_core_packet_v1_packet_proto = out.File + file_tibc_core_packet_v1_packet_proto_rawDesc = nil + file_tibc_core_packet_v1_packet_proto_goTypes = nil + file_tibc_core_packet_v1_packet_proto_depIdxs = nil +} diff --git a/api/tibc/core/packet/v1/query.pulsar.go b/api/tibc/core/packet/v1/query.pulsar.go new file mode 100644 index 00000000..693e7665 --- /dev/null +++ b/api/tibc/core/packet/v1/query.pulsar.go @@ -0,0 +1,10835 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package packetv1 + +import ( + v1beta1 "cosmossdk.io/api/cosmos/base/query/v1beta1" + fmt "fmt" + v1 "github.com/bianjieai/tibc-go/api/tibc/core/client/v1" + runtime "github.com/cosmos/cosmos-proto/runtime" + _ "github.com/cosmos/gogoproto/gogoproto" + _ "google.golang.org/genproto/googleapis/api/annotations" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoiface "google.golang.org/protobuf/runtime/protoiface" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_QueryPacketCommitmentRequest protoreflect.MessageDescriptor + fd_QueryPacketCommitmentRequest_dest_chain protoreflect.FieldDescriptor + fd_QueryPacketCommitmentRequest_source_chain protoreflect.FieldDescriptor + fd_QueryPacketCommitmentRequest_sequence protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_query_proto_init() + md_QueryPacketCommitmentRequest = File_tibc_core_packet_v1_query_proto.Messages().ByName("QueryPacketCommitmentRequest") + fd_QueryPacketCommitmentRequest_dest_chain = md_QueryPacketCommitmentRequest.Fields().ByName("dest_chain") + fd_QueryPacketCommitmentRequest_source_chain = md_QueryPacketCommitmentRequest.Fields().ByName("source_chain") + fd_QueryPacketCommitmentRequest_sequence = md_QueryPacketCommitmentRequest.Fields().ByName("sequence") +} + +var _ protoreflect.Message = (*fastReflection_QueryPacketCommitmentRequest)(nil) + +type fastReflection_QueryPacketCommitmentRequest QueryPacketCommitmentRequest + +func (x *QueryPacketCommitmentRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryPacketCommitmentRequest)(x) +} + +func (x *QueryPacketCommitmentRequest) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryPacketCommitmentRequest_messageType fastReflection_QueryPacketCommitmentRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryPacketCommitmentRequest_messageType{} + +type fastReflection_QueryPacketCommitmentRequest_messageType struct{} + +func (x fastReflection_QueryPacketCommitmentRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryPacketCommitmentRequest)(nil) +} +func (x fastReflection_QueryPacketCommitmentRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryPacketCommitmentRequest) +} +func (x fastReflection_QueryPacketCommitmentRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryPacketCommitmentRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryPacketCommitmentRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryPacketCommitmentRequest +} + +// 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_QueryPacketCommitmentRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryPacketCommitmentRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryPacketCommitmentRequest) New() protoreflect.Message { + return new(fastReflection_QueryPacketCommitmentRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryPacketCommitmentRequest) Interface() protoreflect.ProtoMessage { + return (*QueryPacketCommitmentRequest)(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_QueryPacketCommitmentRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.DestChain != "" { + value := protoreflect.ValueOfString(x.DestChain) + if !f(fd_QueryPacketCommitmentRequest_dest_chain, value) { + return + } + } + if x.SourceChain != "" { + value := protoreflect.ValueOfString(x.SourceChain) + if !f(fd_QueryPacketCommitmentRequest_source_chain, value) { + return + } + } + if x.Sequence != uint64(0) { + value := protoreflect.ValueOfUint64(x.Sequence) + if !f(fd_QueryPacketCommitmentRequest_sequence, 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_QueryPacketCommitmentRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentRequest.dest_chain": + return x.DestChain != "" + case "tibc.core.packet.v1.QueryPacketCommitmentRequest.source_chain": + return x.SourceChain != "" + case "tibc.core.packet.v1.QueryPacketCommitmentRequest.sequence": + return x.Sequence != uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentRequest 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_QueryPacketCommitmentRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentRequest.dest_chain": + x.DestChain = "" + case "tibc.core.packet.v1.QueryPacketCommitmentRequest.source_chain": + x.SourceChain = "" + case "tibc.core.packet.v1.QueryPacketCommitmentRequest.sequence": + x.Sequence = uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentRequest 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_QueryPacketCommitmentRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentRequest.dest_chain": + value := x.DestChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.QueryPacketCommitmentRequest.source_chain": + value := x.SourceChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.QueryPacketCommitmentRequest.sequence": + value := x.Sequence + return protoreflect.ValueOfUint64(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentRequest 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_QueryPacketCommitmentRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentRequest.dest_chain": + x.DestChain = value.Interface().(string) + case "tibc.core.packet.v1.QueryPacketCommitmentRequest.source_chain": + x.SourceChain = value.Interface().(string) + case "tibc.core.packet.v1.QueryPacketCommitmentRequest.sequence": + x.Sequence = value.Uint() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentRequest 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_QueryPacketCommitmentRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentRequest.dest_chain": + panic(fmt.Errorf("field dest_chain of message tibc.core.packet.v1.QueryPacketCommitmentRequest is not mutable")) + case "tibc.core.packet.v1.QueryPacketCommitmentRequest.source_chain": + panic(fmt.Errorf("field source_chain of message tibc.core.packet.v1.QueryPacketCommitmentRequest is not mutable")) + case "tibc.core.packet.v1.QueryPacketCommitmentRequest.sequence": + panic(fmt.Errorf("field sequence of message tibc.core.packet.v1.QueryPacketCommitmentRequest is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentRequest 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_QueryPacketCommitmentRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentRequest.dest_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.QueryPacketCommitmentRequest.source_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.QueryPacketCommitmentRequest.sequence": + return protoreflect.ValueOfUint64(uint64(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentRequest 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_QueryPacketCommitmentRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.QueryPacketCommitmentRequest", 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_QueryPacketCommitmentRequest) 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_QueryPacketCommitmentRequest) 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_QueryPacketCommitmentRequest) 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_QueryPacketCommitmentRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryPacketCommitmentRequest) + 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.DestChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.SourceChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Sequence != 0 { + n += 1 + runtime.Sov(uint64(x.Sequence)) + } + 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().(*QueryPacketCommitmentRequest) + 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.Sequence != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Sequence)) + i-- + dAtA[i] = 0x18 + } + if len(x.SourceChain) > 0 { + i -= len(x.SourceChain) + copy(dAtA[i:], x.SourceChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SourceChain))) + i-- + dAtA[i] = 0x12 + } + if len(x.DestChain) > 0 { + i -= len(x.DestChain) + copy(dAtA[i:], x.DestChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestChain))) + 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().(*QueryPacketCommitmentRequest) + 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: QueryPacketCommitmentRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPacketCommitmentRequest: 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 DestChain", 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.DestChain = 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 SourceChain", 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.SourceChain = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType) + } + x.Sequence = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Sequence |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_QueryPacketCommitmentResponse protoreflect.MessageDescriptor + fd_QueryPacketCommitmentResponse_commitment protoreflect.FieldDescriptor + fd_QueryPacketCommitmentResponse_proof protoreflect.FieldDescriptor + fd_QueryPacketCommitmentResponse_proof_height protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_query_proto_init() + md_QueryPacketCommitmentResponse = File_tibc_core_packet_v1_query_proto.Messages().ByName("QueryPacketCommitmentResponse") + fd_QueryPacketCommitmentResponse_commitment = md_QueryPacketCommitmentResponse.Fields().ByName("commitment") + fd_QueryPacketCommitmentResponse_proof = md_QueryPacketCommitmentResponse.Fields().ByName("proof") + fd_QueryPacketCommitmentResponse_proof_height = md_QueryPacketCommitmentResponse.Fields().ByName("proof_height") +} + +var _ protoreflect.Message = (*fastReflection_QueryPacketCommitmentResponse)(nil) + +type fastReflection_QueryPacketCommitmentResponse QueryPacketCommitmentResponse + +func (x *QueryPacketCommitmentResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryPacketCommitmentResponse)(x) +} + +func (x *QueryPacketCommitmentResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryPacketCommitmentResponse_messageType fastReflection_QueryPacketCommitmentResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryPacketCommitmentResponse_messageType{} + +type fastReflection_QueryPacketCommitmentResponse_messageType struct{} + +func (x fastReflection_QueryPacketCommitmentResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryPacketCommitmentResponse)(nil) +} +func (x fastReflection_QueryPacketCommitmentResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryPacketCommitmentResponse) +} +func (x fastReflection_QueryPacketCommitmentResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryPacketCommitmentResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryPacketCommitmentResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryPacketCommitmentResponse +} + +// 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_QueryPacketCommitmentResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryPacketCommitmentResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryPacketCommitmentResponse) New() protoreflect.Message { + return new(fastReflection_QueryPacketCommitmentResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryPacketCommitmentResponse) Interface() protoreflect.ProtoMessage { + return (*QueryPacketCommitmentResponse)(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_QueryPacketCommitmentResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.Commitment) != 0 { + value := protoreflect.ValueOfBytes(x.Commitment) + if !f(fd_QueryPacketCommitmentResponse_commitment, value) { + return + } + } + if len(x.Proof) != 0 { + value := protoreflect.ValueOfBytes(x.Proof) + if !f(fd_QueryPacketCommitmentResponse_proof, value) { + return + } + } + if x.ProofHeight != nil { + value := protoreflect.ValueOfMessage(x.ProofHeight.ProtoReflect()) + if !f(fd_QueryPacketCommitmentResponse_proof_height, 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_QueryPacketCommitmentResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentResponse.commitment": + return len(x.Commitment) != 0 + case "tibc.core.packet.v1.QueryPacketCommitmentResponse.proof": + return len(x.Proof) != 0 + case "tibc.core.packet.v1.QueryPacketCommitmentResponse.proof_height": + return x.ProofHeight != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentResponse 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_QueryPacketCommitmentResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentResponse.commitment": + x.Commitment = nil + case "tibc.core.packet.v1.QueryPacketCommitmentResponse.proof": + x.Proof = nil + case "tibc.core.packet.v1.QueryPacketCommitmentResponse.proof_height": + x.ProofHeight = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentResponse 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_QueryPacketCommitmentResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentResponse.commitment": + value := x.Commitment + return protoreflect.ValueOfBytes(value) + case "tibc.core.packet.v1.QueryPacketCommitmentResponse.proof": + value := x.Proof + return protoreflect.ValueOfBytes(value) + case "tibc.core.packet.v1.QueryPacketCommitmentResponse.proof_height": + value := x.ProofHeight + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentResponse 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_QueryPacketCommitmentResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentResponse.commitment": + x.Commitment = value.Bytes() + case "tibc.core.packet.v1.QueryPacketCommitmentResponse.proof": + x.Proof = value.Bytes() + case "tibc.core.packet.v1.QueryPacketCommitmentResponse.proof_height": + x.ProofHeight = value.Message().Interface().(*v1.Height) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentResponse 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_QueryPacketCommitmentResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentResponse.proof_height": + if x.ProofHeight == nil { + x.ProofHeight = new(v1.Height) + } + return protoreflect.ValueOfMessage(x.ProofHeight.ProtoReflect()) + case "tibc.core.packet.v1.QueryPacketCommitmentResponse.commitment": + panic(fmt.Errorf("field commitment of message tibc.core.packet.v1.QueryPacketCommitmentResponse is not mutable")) + case "tibc.core.packet.v1.QueryPacketCommitmentResponse.proof": + panic(fmt.Errorf("field proof of message tibc.core.packet.v1.QueryPacketCommitmentResponse is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentResponse 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_QueryPacketCommitmentResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentResponse.commitment": + return protoreflect.ValueOfBytes(nil) + case "tibc.core.packet.v1.QueryPacketCommitmentResponse.proof": + return protoreflect.ValueOfBytes(nil) + case "tibc.core.packet.v1.QueryPacketCommitmentResponse.proof_height": + m := new(v1.Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentResponse 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_QueryPacketCommitmentResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.QueryPacketCommitmentResponse", 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_QueryPacketCommitmentResponse) 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_QueryPacketCommitmentResponse) 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_QueryPacketCommitmentResponse) 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_QueryPacketCommitmentResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryPacketCommitmentResponse) + 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.Commitment) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Proof) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ProofHeight != nil { + l = options.Size(x.ProofHeight) + 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().(*QueryPacketCommitmentResponse) + 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.ProofHeight != nil { + encoded, err := options.Marshal(x.ProofHeight) + 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.Proof) > 0 { + i -= len(x.Proof) + copy(dAtA[i:], x.Proof) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Proof))) + i-- + dAtA[i] = 0x12 + } + if len(x.Commitment) > 0 { + i -= len(x.Commitment) + copy(dAtA[i:], x.Commitment) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Commitment))) + 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().(*QueryPacketCommitmentResponse) + 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: QueryPacketCommitmentResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPacketCommitmentResponse: 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 Commitment", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Commitment = append(x.Commitment[:0], dAtA[iNdEx:postIndex]...) + if x.Commitment == nil { + x.Commitment = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Proof = append(x.Proof[:0], dAtA[iNdEx:postIndex]...) + if x.Proof == nil { + x.Proof = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", 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.ProofHeight == nil { + x.ProofHeight = &v1.Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ProofHeight); 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_QueryPacketCommitmentsRequest protoreflect.MessageDescriptor + fd_QueryPacketCommitmentsRequest_dest_chain protoreflect.FieldDescriptor + fd_QueryPacketCommitmentsRequest_source_chain protoreflect.FieldDescriptor + fd_QueryPacketCommitmentsRequest_pagination protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_query_proto_init() + md_QueryPacketCommitmentsRequest = File_tibc_core_packet_v1_query_proto.Messages().ByName("QueryPacketCommitmentsRequest") + fd_QueryPacketCommitmentsRequest_dest_chain = md_QueryPacketCommitmentsRequest.Fields().ByName("dest_chain") + fd_QueryPacketCommitmentsRequest_source_chain = md_QueryPacketCommitmentsRequest.Fields().ByName("source_chain") + fd_QueryPacketCommitmentsRequest_pagination = md_QueryPacketCommitmentsRequest.Fields().ByName("pagination") +} + +var _ protoreflect.Message = (*fastReflection_QueryPacketCommitmentsRequest)(nil) + +type fastReflection_QueryPacketCommitmentsRequest QueryPacketCommitmentsRequest + +func (x *QueryPacketCommitmentsRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryPacketCommitmentsRequest)(x) +} + +func (x *QueryPacketCommitmentsRequest) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_query_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_QueryPacketCommitmentsRequest_messageType fastReflection_QueryPacketCommitmentsRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryPacketCommitmentsRequest_messageType{} + +type fastReflection_QueryPacketCommitmentsRequest_messageType struct{} + +func (x fastReflection_QueryPacketCommitmentsRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryPacketCommitmentsRequest)(nil) +} +func (x fastReflection_QueryPacketCommitmentsRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryPacketCommitmentsRequest) +} +func (x fastReflection_QueryPacketCommitmentsRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryPacketCommitmentsRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryPacketCommitmentsRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryPacketCommitmentsRequest +} + +// 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_QueryPacketCommitmentsRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryPacketCommitmentsRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryPacketCommitmentsRequest) New() protoreflect.Message { + return new(fastReflection_QueryPacketCommitmentsRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryPacketCommitmentsRequest) Interface() protoreflect.ProtoMessage { + return (*QueryPacketCommitmentsRequest)(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_QueryPacketCommitmentsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.DestChain != "" { + value := protoreflect.ValueOfString(x.DestChain) + if !f(fd_QueryPacketCommitmentsRequest_dest_chain, value) { + return + } + } + if x.SourceChain != "" { + value := protoreflect.ValueOfString(x.SourceChain) + if !f(fd_QueryPacketCommitmentsRequest_source_chain, value) { + return + } + } + if x.Pagination != nil { + value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + if !f(fd_QueryPacketCommitmentsRequest_pagination, 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_QueryPacketCommitmentsRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentsRequest.dest_chain": + return x.DestChain != "" + case "tibc.core.packet.v1.QueryPacketCommitmentsRequest.source_chain": + return x.SourceChain != "" + case "tibc.core.packet.v1.QueryPacketCommitmentsRequest.pagination": + return x.Pagination != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentsRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentsRequest 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_QueryPacketCommitmentsRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentsRequest.dest_chain": + x.DestChain = "" + case "tibc.core.packet.v1.QueryPacketCommitmentsRequest.source_chain": + x.SourceChain = "" + case "tibc.core.packet.v1.QueryPacketCommitmentsRequest.pagination": + x.Pagination = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentsRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentsRequest 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_QueryPacketCommitmentsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentsRequest.dest_chain": + value := x.DestChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.QueryPacketCommitmentsRequest.source_chain": + value := x.SourceChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.QueryPacketCommitmentsRequest.pagination": + value := x.Pagination + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentsRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentsRequest 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_QueryPacketCommitmentsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentsRequest.dest_chain": + x.DestChain = value.Interface().(string) + case "tibc.core.packet.v1.QueryPacketCommitmentsRequest.source_chain": + x.SourceChain = value.Interface().(string) + case "tibc.core.packet.v1.QueryPacketCommitmentsRequest.pagination": + x.Pagination = value.Message().Interface().(*v1beta1.PageRequest) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentsRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentsRequest 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_QueryPacketCommitmentsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentsRequest.pagination": + if x.Pagination == nil { + x.Pagination = new(v1beta1.PageRequest) + } + return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + case "tibc.core.packet.v1.QueryPacketCommitmentsRequest.dest_chain": + panic(fmt.Errorf("field dest_chain of message tibc.core.packet.v1.QueryPacketCommitmentsRequest is not mutable")) + case "tibc.core.packet.v1.QueryPacketCommitmentsRequest.source_chain": + panic(fmt.Errorf("field source_chain of message tibc.core.packet.v1.QueryPacketCommitmentsRequest is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentsRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentsRequest 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_QueryPacketCommitmentsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentsRequest.dest_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.QueryPacketCommitmentsRequest.source_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.QueryPacketCommitmentsRequest.pagination": + m := new(v1beta1.PageRequest) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentsRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentsRequest 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_QueryPacketCommitmentsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.QueryPacketCommitmentsRequest", 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_QueryPacketCommitmentsRequest) 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_QueryPacketCommitmentsRequest) 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_QueryPacketCommitmentsRequest) 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_QueryPacketCommitmentsRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryPacketCommitmentsRequest) + 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.DestChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.SourceChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Pagination != nil { + l = options.Size(x.Pagination) + 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().(*QueryPacketCommitmentsRequest) + 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.Pagination != nil { + encoded, err := options.Marshal(x.Pagination) + 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.SourceChain) > 0 { + i -= len(x.SourceChain) + copy(dAtA[i:], x.SourceChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SourceChain))) + i-- + dAtA[i] = 0x12 + } + if len(x.DestChain) > 0 { + i -= len(x.DestChain) + copy(dAtA[i:], x.DestChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestChain))) + 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().(*QueryPacketCommitmentsRequest) + 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: QueryPacketCommitmentsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPacketCommitmentsRequest: 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 DestChain", 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.DestChain = 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 SourceChain", 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.SourceChain = 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 Pagination", 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.Pagination == nil { + x.Pagination = &v1beta1.PageRequest{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); 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 = (*_QueryPacketCommitmentsResponse_1_list)(nil) + +type _QueryPacketCommitmentsResponse_1_list struct { + list *[]*PacketState +} + +func (x *_QueryPacketCommitmentsResponse_1_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_QueryPacketCommitmentsResponse_1_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_QueryPacketCommitmentsResponse_1_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*PacketState) + (*x.list)[i] = concreteValue +} + +func (x *_QueryPacketCommitmentsResponse_1_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*PacketState) + *x.list = append(*x.list, concreteValue) +} + +func (x *_QueryPacketCommitmentsResponse_1_list) AppendMutable() protoreflect.Value { + v := new(PacketState) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_QueryPacketCommitmentsResponse_1_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_QueryPacketCommitmentsResponse_1_list) NewElement() protoreflect.Value { + v := new(PacketState) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_QueryPacketCommitmentsResponse_1_list) IsValid() bool { + return x.list != nil +} + +var ( + md_QueryPacketCommitmentsResponse protoreflect.MessageDescriptor + fd_QueryPacketCommitmentsResponse_commitments protoreflect.FieldDescriptor + fd_QueryPacketCommitmentsResponse_pagination protoreflect.FieldDescriptor + fd_QueryPacketCommitmentsResponse_height protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_query_proto_init() + md_QueryPacketCommitmentsResponse = File_tibc_core_packet_v1_query_proto.Messages().ByName("QueryPacketCommitmentsResponse") + fd_QueryPacketCommitmentsResponse_commitments = md_QueryPacketCommitmentsResponse.Fields().ByName("commitments") + fd_QueryPacketCommitmentsResponse_pagination = md_QueryPacketCommitmentsResponse.Fields().ByName("pagination") + fd_QueryPacketCommitmentsResponse_height = md_QueryPacketCommitmentsResponse.Fields().ByName("height") +} + +var _ protoreflect.Message = (*fastReflection_QueryPacketCommitmentsResponse)(nil) + +type fastReflection_QueryPacketCommitmentsResponse QueryPacketCommitmentsResponse + +func (x *QueryPacketCommitmentsResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryPacketCommitmentsResponse)(x) +} + +func (x *QueryPacketCommitmentsResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryPacketCommitmentsResponse_messageType fastReflection_QueryPacketCommitmentsResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryPacketCommitmentsResponse_messageType{} + +type fastReflection_QueryPacketCommitmentsResponse_messageType struct{} + +func (x fastReflection_QueryPacketCommitmentsResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryPacketCommitmentsResponse)(nil) +} +func (x fastReflection_QueryPacketCommitmentsResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryPacketCommitmentsResponse) +} +func (x fastReflection_QueryPacketCommitmentsResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryPacketCommitmentsResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryPacketCommitmentsResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryPacketCommitmentsResponse +} + +// 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_QueryPacketCommitmentsResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryPacketCommitmentsResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryPacketCommitmentsResponse) New() protoreflect.Message { + return new(fastReflection_QueryPacketCommitmentsResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryPacketCommitmentsResponse) Interface() protoreflect.ProtoMessage { + return (*QueryPacketCommitmentsResponse)(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_QueryPacketCommitmentsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.Commitments) != 0 { + value := protoreflect.ValueOfList(&_QueryPacketCommitmentsResponse_1_list{list: &x.Commitments}) + if !f(fd_QueryPacketCommitmentsResponse_commitments, value) { + return + } + } + if x.Pagination != nil { + value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + if !f(fd_QueryPacketCommitmentsResponse_pagination, value) { + return + } + } + if x.Height != nil { + value := protoreflect.ValueOfMessage(x.Height.ProtoReflect()) + if !f(fd_QueryPacketCommitmentsResponse_height, 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_QueryPacketCommitmentsResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentsResponse.commitments": + return len(x.Commitments) != 0 + case "tibc.core.packet.v1.QueryPacketCommitmentsResponse.pagination": + return x.Pagination != nil + case "tibc.core.packet.v1.QueryPacketCommitmentsResponse.height": + return x.Height != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentsResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentsResponse 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_QueryPacketCommitmentsResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentsResponse.commitments": + x.Commitments = nil + case "tibc.core.packet.v1.QueryPacketCommitmentsResponse.pagination": + x.Pagination = nil + case "tibc.core.packet.v1.QueryPacketCommitmentsResponse.height": + x.Height = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentsResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentsResponse 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_QueryPacketCommitmentsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentsResponse.commitments": + if len(x.Commitments) == 0 { + return protoreflect.ValueOfList(&_QueryPacketCommitmentsResponse_1_list{}) + } + listValue := &_QueryPacketCommitmentsResponse_1_list{list: &x.Commitments} + return protoreflect.ValueOfList(listValue) + case "tibc.core.packet.v1.QueryPacketCommitmentsResponse.pagination": + value := x.Pagination + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.packet.v1.QueryPacketCommitmentsResponse.height": + value := x.Height + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentsResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentsResponse 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_QueryPacketCommitmentsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentsResponse.commitments": + lv := value.List() + clv := lv.(*_QueryPacketCommitmentsResponse_1_list) + x.Commitments = *clv.list + case "tibc.core.packet.v1.QueryPacketCommitmentsResponse.pagination": + x.Pagination = value.Message().Interface().(*v1beta1.PageResponse) + case "tibc.core.packet.v1.QueryPacketCommitmentsResponse.height": + x.Height = value.Message().Interface().(*v1.Height) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentsResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentsResponse 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_QueryPacketCommitmentsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentsResponse.commitments": + if x.Commitments == nil { + x.Commitments = []*PacketState{} + } + value := &_QueryPacketCommitmentsResponse_1_list{list: &x.Commitments} + return protoreflect.ValueOfList(value) + case "tibc.core.packet.v1.QueryPacketCommitmentsResponse.pagination": + if x.Pagination == nil { + x.Pagination = new(v1beta1.PageResponse) + } + return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + case "tibc.core.packet.v1.QueryPacketCommitmentsResponse.height": + if x.Height == nil { + x.Height = new(v1.Height) + } + return protoreflect.ValueOfMessage(x.Height.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentsResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentsResponse 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_QueryPacketCommitmentsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketCommitmentsResponse.commitments": + list := []*PacketState{} + return protoreflect.ValueOfList(&_QueryPacketCommitmentsResponse_1_list{list: &list}) + case "tibc.core.packet.v1.QueryPacketCommitmentsResponse.pagination": + m := new(v1beta1.PageResponse) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.packet.v1.QueryPacketCommitmentsResponse.height": + m := new(v1.Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketCommitmentsResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketCommitmentsResponse 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_QueryPacketCommitmentsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.QueryPacketCommitmentsResponse", 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_QueryPacketCommitmentsResponse) 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_QueryPacketCommitmentsResponse) 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_QueryPacketCommitmentsResponse) 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_QueryPacketCommitmentsResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryPacketCommitmentsResponse) + 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.Commitments) > 0 { + for _, e := range x.Commitments { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.Pagination != nil { + l = options.Size(x.Pagination) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Height != nil { + l = options.Size(x.Height) + 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().(*QueryPacketCommitmentsResponse) + 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.Height != nil { + encoded, err := options.Marshal(x.Height) + 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.Pagination != nil { + encoded, err := options.Marshal(x.Pagination) + 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.Commitments) > 0 { + for iNdEx := len(x.Commitments) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.Commitments[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().(*QueryPacketCommitmentsResponse) + 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: QueryPacketCommitmentsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPacketCommitmentsResponse: 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 Commitments", 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.Commitments = append(x.Commitments, &PacketState{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Commitments[len(x.Commitments)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", 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.Pagination == nil { + x.Pagination = &v1beta1.PageResponse{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); 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 Height", 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.Height == nil { + x.Height = &v1.Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Height); 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_QueryPacketReceiptRequest protoreflect.MessageDescriptor + fd_QueryPacketReceiptRequest_dest_chain protoreflect.FieldDescriptor + fd_QueryPacketReceiptRequest_source_chain protoreflect.FieldDescriptor + fd_QueryPacketReceiptRequest_sequence protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_query_proto_init() + md_QueryPacketReceiptRequest = File_tibc_core_packet_v1_query_proto.Messages().ByName("QueryPacketReceiptRequest") + fd_QueryPacketReceiptRequest_dest_chain = md_QueryPacketReceiptRequest.Fields().ByName("dest_chain") + fd_QueryPacketReceiptRequest_source_chain = md_QueryPacketReceiptRequest.Fields().ByName("source_chain") + fd_QueryPacketReceiptRequest_sequence = md_QueryPacketReceiptRequest.Fields().ByName("sequence") +} + +var _ protoreflect.Message = (*fastReflection_QueryPacketReceiptRequest)(nil) + +type fastReflection_QueryPacketReceiptRequest QueryPacketReceiptRequest + +func (x *QueryPacketReceiptRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryPacketReceiptRequest)(x) +} + +func (x *QueryPacketReceiptRequest) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_query_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_QueryPacketReceiptRequest_messageType fastReflection_QueryPacketReceiptRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryPacketReceiptRequest_messageType{} + +type fastReflection_QueryPacketReceiptRequest_messageType struct{} + +func (x fastReflection_QueryPacketReceiptRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryPacketReceiptRequest)(nil) +} +func (x fastReflection_QueryPacketReceiptRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryPacketReceiptRequest) +} +func (x fastReflection_QueryPacketReceiptRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryPacketReceiptRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryPacketReceiptRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryPacketReceiptRequest +} + +// 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_QueryPacketReceiptRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryPacketReceiptRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryPacketReceiptRequest) New() protoreflect.Message { + return new(fastReflection_QueryPacketReceiptRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryPacketReceiptRequest) Interface() protoreflect.ProtoMessage { + return (*QueryPacketReceiptRequest)(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_QueryPacketReceiptRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.DestChain != "" { + value := protoreflect.ValueOfString(x.DestChain) + if !f(fd_QueryPacketReceiptRequest_dest_chain, value) { + return + } + } + if x.SourceChain != "" { + value := protoreflect.ValueOfString(x.SourceChain) + if !f(fd_QueryPacketReceiptRequest_source_chain, value) { + return + } + } + if x.Sequence != uint64(0) { + value := protoreflect.ValueOfUint64(x.Sequence) + if !f(fd_QueryPacketReceiptRequest_sequence, 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_QueryPacketReceiptRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketReceiptRequest.dest_chain": + return x.DestChain != "" + case "tibc.core.packet.v1.QueryPacketReceiptRequest.source_chain": + return x.SourceChain != "" + case "tibc.core.packet.v1.QueryPacketReceiptRequest.sequence": + return x.Sequence != uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketReceiptRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketReceiptRequest 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_QueryPacketReceiptRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketReceiptRequest.dest_chain": + x.DestChain = "" + case "tibc.core.packet.v1.QueryPacketReceiptRequest.source_chain": + x.SourceChain = "" + case "tibc.core.packet.v1.QueryPacketReceiptRequest.sequence": + x.Sequence = uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketReceiptRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketReceiptRequest 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_QueryPacketReceiptRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.QueryPacketReceiptRequest.dest_chain": + value := x.DestChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.QueryPacketReceiptRequest.source_chain": + value := x.SourceChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.QueryPacketReceiptRequest.sequence": + value := x.Sequence + return protoreflect.ValueOfUint64(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketReceiptRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketReceiptRequest 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_QueryPacketReceiptRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketReceiptRequest.dest_chain": + x.DestChain = value.Interface().(string) + case "tibc.core.packet.v1.QueryPacketReceiptRequest.source_chain": + x.SourceChain = value.Interface().(string) + case "tibc.core.packet.v1.QueryPacketReceiptRequest.sequence": + x.Sequence = value.Uint() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketReceiptRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketReceiptRequest 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_QueryPacketReceiptRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketReceiptRequest.dest_chain": + panic(fmt.Errorf("field dest_chain of message tibc.core.packet.v1.QueryPacketReceiptRequest is not mutable")) + case "tibc.core.packet.v1.QueryPacketReceiptRequest.source_chain": + panic(fmt.Errorf("field source_chain of message tibc.core.packet.v1.QueryPacketReceiptRequest is not mutable")) + case "tibc.core.packet.v1.QueryPacketReceiptRequest.sequence": + panic(fmt.Errorf("field sequence of message tibc.core.packet.v1.QueryPacketReceiptRequest is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketReceiptRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketReceiptRequest 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_QueryPacketReceiptRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketReceiptRequest.dest_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.QueryPacketReceiptRequest.source_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.QueryPacketReceiptRequest.sequence": + return protoreflect.ValueOfUint64(uint64(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketReceiptRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketReceiptRequest 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_QueryPacketReceiptRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.QueryPacketReceiptRequest", 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_QueryPacketReceiptRequest) 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_QueryPacketReceiptRequest) 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_QueryPacketReceiptRequest) 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_QueryPacketReceiptRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryPacketReceiptRequest) + 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.DestChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.SourceChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Sequence != 0 { + n += 1 + runtime.Sov(uint64(x.Sequence)) + } + 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().(*QueryPacketReceiptRequest) + 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.Sequence != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Sequence)) + i-- + dAtA[i] = 0x18 + } + if len(x.SourceChain) > 0 { + i -= len(x.SourceChain) + copy(dAtA[i:], x.SourceChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SourceChain))) + i-- + dAtA[i] = 0x12 + } + if len(x.DestChain) > 0 { + i -= len(x.DestChain) + copy(dAtA[i:], x.DestChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestChain))) + 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().(*QueryPacketReceiptRequest) + 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: QueryPacketReceiptRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPacketReceiptRequest: 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 DestChain", 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.DestChain = 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 SourceChain", 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.SourceChain = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType) + } + x.Sequence = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Sequence |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_QueryPacketReceiptResponse protoreflect.MessageDescriptor + fd_QueryPacketReceiptResponse_received protoreflect.FieldDescriptor + fd_QueryPacketReceiptResponse_proof protoreflect.FieldDescriptor + fd_QueryPacketReceiptResponse_proof_height protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_query_proto_init() + md_QueryPacketReceiptResponse = File_tibc_core_packet_v1_query_proto.Messages().ByName("QueryPacketReceiptResponse") + fd_QueryPacketReceiptResponse_received = md_QueryPacketReceiptResponse.Fields().ByName("received") + fd_QueryPacketReceiptResponse_proof = md_QueryPacketReceiptResponse.Fields().ByName("proof") + fd_QueryPacketReceiptResponse_proof_height = md_QueryPacketReceiptResponse.Fields().ByName("proof_height") +} + +var _ protoreflect.Message = (*fastReflection_QueryPacketReceiptResponse)(nil) + +type fastReflection_QueryPacketReceiptResponse QueryPacketReceiptResponse + +func (x *QueryPacketReceiptResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryPacketReceiptResponse)(x) +} + +func (x *QueryPacketReceiptResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryPacketReceiptResponse_messageType fastReflection_QueryPacketReceiptResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryPacketReceiptResponse_messageType{} + +type fastReflection_QueryPacketReceiptResponse_messageType struct{} + +func (x fastReflection_QueryPacketReceiptResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryPacketReceiptResponse)(nil) +} +func (x fastReflection_QueryPacketReceiptResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryPacketReceiptResponse) +} +func (x fastReflection_QueryPacketReceiptResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryPacketReceiptResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryPacketReceiptResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryPacketReceiptResponse +} + +// 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_QueryPacketReceiptResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryPacketReceiptResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryPacketReceiptResponse) New() protoreflect.Message { + return new(fastReflection_QueryPacketReceiptResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryPacketReceiptResponse) Interface() protoreflect.ProtoMessage { + return (*QueryPacketReceiptResponse)(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_QueryPacketReceiptResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Received != false { + value := protoreflect.ValueOfBool(x.Received) + if !f(fd_QueryPacketReceiptResponse_received, value) { + return + } + } + if len(x.Proof) != 0 { + value := protoreflect.ValueOfBytes(x.Proof) + if !f(fd_QueryPacketReceiptResponse_proof, value) { + return + } + } + if x.ProofHeight != nil { + value := protoreflect.ValueOfMessage(x.ProofHeight.ProtoReflect()) + if !f(fd_QueryPacketReceiptResponse_proof_height, 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_QueryPacketReceiptResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketReceiptResponse.received": + return x.Received != false + case "tibc.core.packet.v1.QueryPacketReceiptResponse.proof": + return len(x.Proof) != 0 + case "tibc.core.packet.v1.QueryPacketReceiptResponse.proof_height": + return x.ProofHeight != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketReceiptResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketReceiptResponse 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_QueryPacketReceiptResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketReceiptResponse.received": + x.Received = false + case "tibc.core.packet.v1.QueryPacketReceiptResponse.proof": + x.Proof = nil + case "tibc.core.packet.v1.QueryPacketReceiptResponse.proof_height": + x.ProofHeight = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketReceiptResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketReceiptResponse 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_QueryPacketReceiptResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.QueryPacketReceiptResponse.received": + value := x.Received + return protoreflect.ValueOfBool(value) + case "tibc.core.packet.v1.QueryPacketReceiptResponse.proof": + value := x.Proof + return protoreflect.ValueOfBytes(value) + case "tibc.core.packet.v1.QueryPacketReceiptResponse.proof_height": + value := x.ProofHeight + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketReceiptResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketReceiptResponse 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_QueryPacketReceiptResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketReceiptResponse.received": + x.Received = value.Bool() + case "tibc.core.packet.v1.QueryPacketReceiptResponse.proof": + x.Proof = value.Bytes() + case "tibc.core.packet.v1.QueryPacketReceiptResponse.proof_height": + x.ProofHeight = value.Message().Interface().(*v1.Height) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketReceiptResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketReceiptResponse 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_QueryPacketReceiptResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketReceiptResponse.proof_height": + if x.ProofHeight == nil { + x.ProofHeight = new(v1.Height) + } + return protoreflect.ValueOfMessage(x.ProofHeight.ProtoReflect()) + case "tibc.core.packet.v1.QueryPacketReceiptResponse.received": + panic(fmt.Errorf("field received of message tibc.core.packet.v1.QueryPacketReceiptResponse is not mutable")) + case "tibc.core.packet.v1.QueryPacketReceiptResponse.proof": + panic(fmt.Errorf("field proof of message tibc.core.packet.v1.QueryPacketReceiptResponse is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketReceiptResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketReceiptResponse 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_QueryPacketReceiptResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketReceiptResponse.received": + return protoreflect.ValueOfBool(false) + case "tibc.core.packet.v1.QueryPacketReceiptResponse.proof": + return protoreflect.ValueOfBytes(nil) + case "tibc.core.packet.v1.QueryPacketReceiptResponse.proof_height": + m := new(v1.Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketReceiptResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketReceiptResponse 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_QueryPacketReceiptResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.QueryPacketReceiptResponse", 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_QueryPacketReceiptResponse) 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_QueryPacketReceiptResponse) 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_QueryPacketReceiptResponse) 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_QueryPacketReceiptResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryPacketReceiptResponse) + 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.Received { + n += 2 + } + l = len(x.Proof) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ProofHeight != nil { + l = options.Size(x.ProofHeight) + 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().(*QueryPacketReceiptResponse) + 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.ProofHeight != nil { + encoded, err := options.Marshal(x.ProofHeight) + 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] = 0x22 + } + if len(x.Proof) > 0 { + i -= len(x.Proof) + copy(dAtA[i:], x.Proof) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Proof))) + i-- + dAtA[i] = 0x1a + } + if x.Received { + i-- + if x.Received { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + } + 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().(*QueryPacketReceiptResponse) + 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: QueryPacketReceiptResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPacketReceiptResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Received", wireType) + } + var v 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++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.Received = bool(v != 0) + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Proof = append(x.Proof[:0], dAtA[iNdEx:postIndex]...) + if x.Proof == nil { + x.Proof = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", 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.ProofHeight == nil { + x.ProofHeight = &v1.Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ProofHeight); 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_QueryPacketAcknowledgementRequest protoreflect.MessageDescriptor + fd_QueryPacketAcknowledgementRequest_dest_chain protoreflect.FieldDescriptor + fd_QueryPacketAcknowledgementRequest_source_chain protoreflect.FieldDescriptor + fd_QueryPacketAcknowledgementRequest_sequence protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_query_proto_init() + md_QueryPacketAcknowledgementRequest = File_tibc_core_packet_v1_query_proto.Messages().ByName("QueryPacketAcknowledgementRequest") + fd_QueryPacketAcknowledgementRequest_dest_chain = md_QueryPacketAcknowledgementRequest.Fields().ByName("dest_chain") + fd_QueryPacketAcknowledgementRequest_source_chain = md_QueryPacketAcknowledgementRequest.Fields().ByName("source_chain") + fd_QueryPacketAcknowledgementRequest_sequence = md_QueryPacketAcknowledgementRequest.Fields().ByName("sequence") +} + +var _ protoreflect.Message = (*fastReflection_QueryPacketAcknowledgementRequest)(nil) + +type fastReflection_QueryPacketAcknowledgementRequest QueryPacketAcknowledgementRequest + +func (x *QueryPacketAcknowledgementRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryPacketAcknowledgementRequest)(x) +} + +func (x *QueryPacketAcknowledgementRequest) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_query_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_QueryPacketAcknowledgementRequest_messageType fastReflection_QueryPacketAcknowledgementRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryPacketAcknowledgementRequest_messageType{} + +type fastReflection_QueryPacketAcknowledgementRequest_messageType struct{} + +func (x fastReflection_QueryPacketAcknowledgementRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryPacketAcknowledgementRequest)(nil) +} +func (x fastReflection_QueryPacketAcknowledgementRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryPacketAcknowledgementRequest) +} +func (x fastReflection_QueryPacketAcknowledgementRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryPacketAcknowledgementRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryPacketAcknowledgementRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryPacketAcknowledgementRequest +} + +// 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_QueryPacketAcknowledgementRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryPacketAcknowledgementRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryPacketAcknowledgementRequest) New() protoreflect.Message { + return new(fastReflection_QueryPacketAcknowledgementRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryPacketAcknowledgementRequest) Interface() protoreflect.ProtoMessage { + return (*QueryPacketAcknowledgementRequest)(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_QueryPacketAcknowledgementRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.DestChain != "" { + value := protoreflect.ValueOfString(x.DestChain) + if !f(fd_QueryPacketAcknowledgementRequest_dest_chain, value) { + return + } + } + if x.SourceChain != "" { + value := protoreflect.ValueOfString(x.SourceChain) + if !f(fd_QueryPacketAcknowledgementRequest_source_chain, value) { + return + } + } + if x.Sequence != uint64(0) { + value := protoreflect.ValueOfUint64(x.Sequence) + if !f(fd_QueryPacketAcknowledgementRequest_sequence, 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_QueryPacketAcknowledgementRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementRequest.dest_chain": + return x.DestChain != "" + case "tibc.core.packet.v1.QueryPacketAcknowledgementRequest.source_chain": + return x.SourceChain != "" + case "tibc.core.packet.v1.QueryPacketAcknowledgementRequest.sequence": + return x.Sequence != uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementRequest 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_QueryPacketAcknowledgementRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementRequest.dest_chain": + x.DestChain = "" + case "tibc.core.packet.v1.QueryPacketAcknowledgementRequest.source_chain": + x.SourceChain = "" + case "tibc.core.packet.v1.QueryPacketAcknowledgementRequest.sequence": + x.Sequence = uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementRequest 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_QueryPacketAcknowledgementRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementRequest.dest_chain": + value := x.DestChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.QueryPacketAcknowledgementRequest.source_chain": + value := x.SourceChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.QueryPacketAcknowledgementRequest.sequence": + value := x.Sequence + return protoreflect.ValueOfUint64(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementRequest 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_QueryPacketAcknowledgementRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementRequest.dest_chain": + x.DestChain = value.Interface().(string) + case "tibc.core.packet.v1.QueryPacketAcknowledgementRequest.source_chain": + x.SourceChain = value.Interface().(string) + case "tibc.core.packet.v1.QueryPacketAcknowledgementRequest.sequence": + x.Sequence = value.Uint() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementRequest 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_QueryPacketAcknowledgementRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementRequest.dest_chain": + panic(fmt.Errorf("field dest_chain of message tibc.core.packet.v1.QueryPacketAcknowledgementRequest is not mutable")) + case "tibc.core.packet.v1.QueryPacketAcknowledgementRequest.source_chain": + panic(fmt.Errorf("field source_chain of message tibc.core.packet.v1.QueryPacketAcknowledgementRequest is not mutable")) + case "tibc.core.packet.v1.QueryPacketAcknowledgementRequest.sequence": + panic(fmt.Errorf("field sequence of message tibc.core.packet.v1.QueryPacketAcknowledgementRequest is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementRequest 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_QueryPacketAcknowledgementRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementRequest.dest_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.QueryPacketAcknowledgementRequest.source_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.QueryPacketAcknowledgementRequest.sequence": + return protoreflect.ValueOfUint64(uint64(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementRequest 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_QueryPacketAcknowledgementRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.QueryPacketAcknowledgementRequest", 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_QueryPacketAcknowledgementRequest) 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_QueryPacketAcknowledgementRequest) 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_QueryPacketAcknowledgementRequest) 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_QueryPacketAcknowledgementRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryPacketAcknowledgementRequest) + 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.DestChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.SourceChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Sequence != 0 { + n += 1 + runtime.Sov(uint64(x.Sequence)) + } + 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().(*QueryPacketAcknowledgementRequest) + 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.Sequence != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Sequence)) + i-- + dAtA[i] = 0x18 + } + if len(x.SourceChain) > 0 { + i -= len(x.SourceChain) + copy(dAtA[i:], x.SourceChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SourceChain))) + i-- + dAtA[i] = 0x12 + } + if len(x.DestChain) > 0 { + i -= len(x.DestChain) + copy(dAtA[i:], x.DestChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestChain))) + 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().(*QueryPacketAcknowledgementRequest) + 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: QueryPacketAcknowledgementRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPacketAcknowledgementRequest: 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 DestChain", 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.DestChain = 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 SourceChain", 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.SourceChain = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType) + } + x.Sequence = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Sequence |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_QueryPacketAcknowledgementResponse protoreflect.MessageDescriptor + fd_QueryPacketAcknowledgementResponse_acknowledgement protoreflect.FieldDescriptor + fd_QueryPacketAcknowledgementResponse_proof protoreflect.FieldDescriptor + fd_QueryPacketAcknowledgementResponse_proof_height protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_query_proto_init() + md_QueryPacketAcknowledgementResponse = File_tibc_core_packet_v1_query_proto.Messages().ByName("QueryPacketAcknowledgementResponse") + fd_QueryPacketAcknowledgementResponse_acknowledgement = md_QueryPacketAcknowledgementResponse.Fields().ByName("acknowledgement") + fd_QueryPacketAcknowledgementResponse_proof = md_QueryPacketAcknowledgementResponse.Fields().ByName("proof") + fd_QueryPacketAcknowledgementResponse_proof_height = md_QueryPacketAcknowledgementResponse.Fields().ByName("proof_height") +} + +var _ protoreflect.Message = (*fastReflection_QueryPacketAcknowledgementResponse)(nil) + +type fastReflection_QueryPacketAcknowledgementResponse QueryPacketAcknowledgementResponse + +func (x *QueryPacketAcknowledgementResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryPacketAcknowledgementResponse)(x) +} + +func (x *QueryPacketAcknowledgementResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryPacketAcknowledgementResponse_messageType fastReflection_QueryPacketAcknowledgementResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryPacketAcknowledgementResponse_messageType{} + +type fastReflection_QueryPacketAcknowledgementResponse_messageType struct{} + +func (x fastReflection_QueryPacketAcknowledgementResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryPacketAcknowledgementResponse)(nil) +} +func (x fastReflection_QueryPacketAcknowledgementResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryPacketAcknowledgementResponse) +} +func (x fastReflection_QueryPacketAcknowledgementResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryPacketAcknowledgementResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryPacketAcknowledgementResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryPacketAcknowledgementResponse +} + +// 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_QueryPacketAcknowledgementResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryPacketAcknowledgementResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryPacketAcknowledgementResponse) New() protoreflect.Message { + return new(fastReflection_QueryPacketAcknowledgementResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryPacketAcknowledgementResponse) Interface() protoreflect.ProtoMessage { + return (*QueryPacketAcknowledgementResponse)(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_QueryPacketAcknowledgementResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.Acknowledgement) != 0 { + value := protoreflect.ValueOfBytes(x.Acknowledgement) + if !f(fd_QueryPacketAcknowledgementResponse_acknowledgement, value) { + return + } + } + if len(x.Proof) != 0 { + value := protoreflect.ValueOfBytes(x.Proof) + if !f(fd_QueryPacketAcknowledgementResponse_proof, value) { + return + } + } + if x.ProofHeight != nil { + value := protoreflect.ValueOfMessage(x.ProofHeight.ProtoReflect()) + if !f(fd_QueryPacketAcknowledgementResponse_proof_height, 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_QueryPacketAcknowledgementResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementResponse.acknowledgement": + return len(x.Acknowledgement) != 0 + case "tibc.core.packet.v1.QueryPacketAcknowledgementResponse.proof": + return len(x.Proof) != 0 + case "tibc.core.packet.v1.QueryPacketAcknowledgementResponse.proof_height": + return x.ProofHeight != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementResponse 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_QueryPacketAcknowledgementResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementResponse.acknowledgement": + x.Acknowledgement = nil + case "tibc.core.packet.v1.QueryPacketAcknowledgementResponse.proof": + x.Proof = nil + case "tibc.core.packet.v1.QueryPacketAcknowledgementResponse.proof_height": + x.ProofHeight = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementResponse 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_QueryPacketAcknowledgementResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementResponse.acknowledgement": + value := x.Acknowledgement + return protoreflect.ValueOfBytes(value) + case "tibc.core.packet.v1.QueryPacketAcknowledgementResponse.proof": + value := x.Proof + return protoreflect.ValueOfBytes(value) + case "tibc.core.packet.v1.QueryPacketAcknowledgementResponse.proof_height": + value := x.ProofHeight + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementResponse 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_QueryPacketAcknowledgementResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementResponse.acknowledgement": + x.Acknowledgement = value.Bytes() + case "tibc.core.packet.v1.QueryPacketAcknowledgementResponse.proof": + x.Proof = value.Bytes() + case "tibc.core.packet.v1.QueryPacketAcknowledgementResponse.proof_height": + x.ProofHeight = value.Message().Interface().(*v1.Height) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementResponse 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_QueryPacketAcknowledgementResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementResponse.proof_height": + if x.ProofHeight == nil { + x.ProofHeight = new(v1.Height) + } + return protoreflect.ValueOfMessage(x.ProofHeight.ProtoReflect()) + case "tibc.core.packet.v1.QueryPacketAcknowledgementResponse.acknowledgement": + panic(fmt.Errorf("field acknowledgement of message tibc.core.packet.v1.QueryPacketAcknowledgementResponse is not mutable")) + case "tibc.core.packet.v1.QueryPacketAcknowledgementResponse.proof": + panic(fmt.Errorf("field proof of message tibc.core.packet.v1.QueryPacketAcknowledgementResponse is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementResponse 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_QueryPacketAcknowledgementResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementResponse.acknowledgement": + return protoreflect.ValueOfBytes(nil) + case "tibc.core.packet.v1.QueryPacketAcknowledgementResponse.proof": + return protoreflect.ValueOfBytes(nil) + case "tibc.core.packet.v1.QueryPacketAcknowledgementResponse.proof_height": + m := new(v1.Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementResponse 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_QueryPacketAcknowledgementResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.QueryPacketAcknowledgementResponse", 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_QueryPacketAcknowledgementResponse) 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_QueryPacketAcknowledgementResponse) 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_QueryPacketAcknowledgementResponse) 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_QueryPacketAcknowledgementResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryPacketAcknowledgementResponse) + 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.Acknowledgement) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Proof) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ProofHeight != nil { + l = options.Size(x.ProofHeight) + 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().(*QueryPacketAcknowledgementResponse) + 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.ProofHeight != nil { + encoded, err := options.Marshal(x.ProofHeight) + 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.Proof) > 0 { + i -= len(x.Proof) + copy(dAtA[i:], x.Proof) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Proof))) + i-- + dAtA[i] = 0x12 + } + if len(x.Acknowledgement) > 0 { + i -= len(x.Acknowledgement) + copy(dAtA[i:], x.Acknowledgement) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Acknowledgement))) + 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().(*QueryPacketAcknowledgementResponse) + 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: QueryPacketAcknowledgementResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPacketAcknowledgementResponse: 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 Acknowledgement", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Acknowledgement = append(x.Acknowledgement[:0], dAtA[iNdEx:postIndex]...) + if x.Acknowledgement == nil { + x.Acknowledgement = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Proof = append(x.Proof[:0], dAtA[iNdEx:postIndex]...) + if x.Proof == nil { + x.Proof = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", 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.ProofHeight == nil { + x.ProofHeight = &v1.Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ProofHeight); 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_QueryPacketAcknowledgementsRequest protoreflect.MessageDescriptor + fd_QueryPacketAcknowledgementsRequest_dest_chain protoreflect.FieldDescriptor + fd_QueryPacketAcknowledgementsRequest_source_chain protoreflect.FieldDescriptor + fd_QueryPacketAcknowledgementsRequest_pagination protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_query_proto_init() + md_QueryPacketAcknowledgementsRequest = File_tibc_core_packet_v1_query_proto.Messages().ByName("QueryPacketAcknowledgementsRequest") + fd_QueryPacketAcknowledgementsRequest_dest_chain = md_QueryPacketAcknowledgementsRequest.Fields().ByName("dest_chain") + fd_QueryPacketAcknowledgementsRequest_source_chain = md_QueryPacketAcknowledgementsRequest.Fields().ByName("source_chain") + fd_QueryPacketAcknowledgementsRequest_pagination = md_QueryPacketAcknowledgementsRequest.Fields().ByName("pagination") +} + +var _ protoreflect.Message = (*fastReflection_QueryPacketAcknowledgementsRequest)(nil) + +type fastReflection_QueryPacketAcknowledgementsRequest QueryPacketAcknowledgementsRequest + +func (x *QueryPacketAcknowledgementsRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryPacketAcknowledgementsRequest)(x) +} + +func (x *QueryPacketAcknowledgementsRequest) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_query_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_QueryPacketAcknowledgementsRequest_messageType fastReflection_QueryPacketAcknowledgementsRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryPacketAcknowledgementsRequest_messageType{} + +type fastReflection_QueryPacketAcknowledgementsRequest_messageType struct{} + +func (x fastReflection_QueryPacketAcknowledgementsRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryPacketAcknowledgementsRequest)(nil) +} +func (x fastReflection_QueryPacketAcknowledgementsRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryPacketAcknowledgementsRequest) +} +func (x fastReflection_QueryPacketAcknowledgementsRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryPacketAcknowledgementsRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryPacketAcknowledgementsRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryPacketAcknowledgementsRequest +} + +// 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_QueryPacketAcknowledgementsRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryPacketAcknowledgementsRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryPacketAcknowledgementsRequest) New() protoreflect.Message { + return new(fastReflection_QueryPacketAcknowledgementsRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryPacketAcknowledgementsRequest) Interface() protoreflect.ProtoMessage { + return (*QueryPacketAcknowledgementsRequest)(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_QueryPacketAcknowledgementsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.DestChain != "" { + value := protoreflect.ValueOfString(x.DestChain) + if !f(fd_QueryPacketAcknowledgementsRequest_dest_chain, value) { + return + } + } + if x.SourceChain != "" { + value := protoreflect.ValueOfString(x.SourceChain) + if !f(fd_QueryPacketAcknowledgementsRequest_source_chain, value) { + return + } + } + if x.Pagination != nil { + value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + if !f(fd_QueryPacketAcknowledgementsRequest_pagination, 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_QueryPacketAcknowledgementsRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementsRequest.dest_chain": + return x.DestChain != "" + case "tibc.core.packet.v1.QueryPacketAcknowledgementsRequest.source_chain": + return x.SourceChain != "" + case "tibc.core.packet.v1.QueryPacketAcknowledgementsRequest.pagination": + return x.Pagination != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementsRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementsRequest 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_QueryPacketAcknowledgementsRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementsRequest.dest_chain": + x.DestChain = "" + case "tibc.core.packet.v1.QueryPacketAcknowledgementsRequest.source_chain": + x.SourceChain = "" + case "tibc.core.packet.v1.QueryPacketAcknowledgementsRequest.pagination": + x.Pagination = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementsRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementsRequest 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_QueryPacketAcknowledgementsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementsRequest.dest_chain": + value := x.DestChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.QueryPacketAcknowledgementsRequest.source_chain": + value := x.SourceChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.QueryPacketAcknowledgementsRequest.pagination": + value := x.Pagination + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementsRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementsRequest 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_QueryPacketAcknowledgementsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementsRequest.dest_chain": + x.DestChain = value.Interface().(string) + case "tibc.core.packet.v1.QueryPacketAcknowledgementsRequest.source_chain": + x.SourceChain = value.Interface().(string) + case "tibc.core.packet.v1.QueryPacketAcknowledgementsRequest.pagination": + x.Pagination = value.Message().Interface().(*v1beta1.PageRequest) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementsRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementsRequest 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_QueryPacketAcknowledgementsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementsRequest.pagination": + if x.Pagination == nil { + x.Pagination = new(v1beta1.PageRequest) + } + return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + case "tibc.core.packet.v1.QueryPacketAcknowledgementsRequest.dest_chain": + panic(fmt.Errorf("field dest_chain of message tibc.core.packet.v1.QueryPacketAcknowledgementsRequest is not mutable")) + case "tibc.core.packet.v1.QueryPacketAcknowledgementsRequest.source_chain": + panic(fmt.Errorf("field source_chain of message tibc.core.packet.v1.QueryPacketAcknowledgementsRequest is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementsRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementsRequest 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_QueryPacketAcknowledgementsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementsRequest.dest_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.QueryPacketAcknowledgementsRequest.source_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.QueryPacketAcknowledgementsRequest.pagination": + m := new(v1beta1.PageRequest) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementsRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementsRequest 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_QueryPacketAcknowledgementsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.QueryPacketAcknowledgementsRequest", 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_QueryPacketAcknowledgementsRequest) 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_QueryPacketAcknowledgementsRequest) 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_QueryPacketAcknowledgementsRequest) 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_QueryPacketAcknowledgementsRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryPacketAcknowledgementsRequest) + 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.DestChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.SourceChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Pagination != nil { + l = options.Size(x.Pagination) + 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().(*QueryPacketAcknowledgementsRequest) + 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.Pagination != nil { + encoded, err := options.Marshal(x.Pagination) + 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.SourceChain) > 0 { + i -= len(x.SourceChain) + copy(dAtA[i:], x.SourceChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SourceChain))) + i-- + dAtA[i] = 0x12 + } + if len(x.DestChain) > 0 { + i -= len(x.DestChain) + copy(dAtA[i:], x.DestChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestChain))) + 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().(*QueryPacketAcknowledgementsRequest) + 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: QueryPacketAcknowledgementsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPacketAcknowledgementsRequest: 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 DestChain", 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.DestChain = 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 SourceChain", 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.SourceChain = 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 Pagination", 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.Pagination == nil { + x.Pagination = &v1beta1.PageRequest{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); 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 = (*_QueryPacketAcknowledgementsResponse_1_list)(nil) + +type _QueryPacketAcknowledgementsResponse_1_list struct { + list *[]*PacketState +} + +func (x *_QueryPacketAcknowledgementsResponse_1_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_QueryPacketAcknowledgementsResponse_1_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_QueryPacketAcknowledgementsResponse_1_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*PacketState) + (*x.list)[i] = concreteValue +} + +func (x *_QueryPacketAcknowledgementsResponse_1_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*PacketState) + *x.list = append(*x.list, concreteValue) +} + +func (x *_QueryPacketAcknowledgementsResponse_1_list) AppendMutable() protoreflect.Value { + v := new(PacketState) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_QueryPacketAcknowledgementsResponse_1_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_QueryPacketAcknowledgementsResponse_1_list) NewElement() protoreflect.Value { + v := new(PacketState) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_QueryPacketAcknowledgementsResponse_1_list) IsValid() bool { + return x.list != nil +} + +var ( + md_QueryPacketAcknowledgementsResponse protoreflect.MessageDescriptor + fd_QueryPacketAcknowledgementsResponse_acknowledgements protoreflect.FieldDescriptor + fd_QueryPacketAcknowledgementsResponse_pagination protoreflect.FieldDescriptor + fd_QueryPacketAcknowledgementsResponse_height protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_query_proto_init() + md_QueryPacketAcknowledgementsResponse = File_tibc_core_packet_v1_query_proto.Messages().ByName("QueryPacketAcknowledgementsResponse") + fd_QueryPacketAcknowledgementsResponse_acknowledgements = md_QueryPacketAcknowledgementsResponse.Fields().ByName("acknowledgements") + fd_QueryPacketAcknowledgementsResponse_pagination = md_QueryPacketAcknowledgementsResponse.Fields().ByName("pagination") + fd_QueryPacketAcknowledgementsResponse_height = md_QueryPacketAcknowledgementsResponse.Fields().ByName("height") +} + +var _ protoreflect.Message = (*fastReflection_QueryPacketAcknowledgementsResponse)(nil) + +type fastReflection_QueryPacketAcknowledgementsResponse QueryPacketAcknowledgementsResponse + +func (x *QueryPacketAcknowledgementsResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryPacketAcknowledgementsResponse)(x) +} + +func (x *QueryPacketAcknowledgementsResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryPacketAcknowledgementsResponse_messageType fastReflection_QueryPacketAcknowledgementsResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryPacketAcknowledgementsResponse_messageType{} + +type fastReflection_QueryPacketAcknowledgementsResponse_messageType struct{} + +func (x fastReflection_QueryPacketAcknowledgementsResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryPacketAcknowledgementsResponse)(nil) +} +func (x fastReflection_QueryPacketAcknowledgementsResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryPacketAcknowledgementsResponse) +} +func (x fastReflection_QueryPacketAcknowledgementsResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryPacketAcknowledgementsResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryPacketAcknowledgementsResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryPacketAcknowledgementsResponse +} + +// 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_QueryPacketAcknowledgementsResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryPacketAcknowledgementsResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryPacketAcknowledgementsResponse) New() protoreflect.Message { + return new(fastReflection_QueryPacketAcknowledgementsResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryPacketAcknowledgementsResponse) Interface() protoreflect.ProtoMessage { + return (*QueryPacketAcknowledgementsResponse)(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_QueryPacketAcknowledgementsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.Acknowledgements) != 0 { + value := protoreflect.ValueOfList(&_QueryPacketAcknowledgementsResponse_1_list{list: &x.Acknowledgements}) + if !f(fd_QueryPacketAcknowledgementsResponse_acknowledgements, value) { + return + } + } + if x.Pagination != nil { + value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + if !f(fd_QueryPacketAcknowledgementsResponse_pagination, value) { + return + } + } + if x.Height != nil { + value := protoreflect.ValueOfMessage(x.Height.ProtoReflect()) + if !f(fd_QueryPacketAcknowledgementsResponse_height, 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_QueryPacketAcknowledgementsResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.acknowledgements": + return len(x.Acknowledgements) != 0 + case "tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.pagination": + return x.Pagination != nil + case "tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.height": + return x.Height != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementsResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementsResponse 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_QueryPacketAcknowledgementsResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.acknowledgements": + x.Acknowledgements = nil + case "tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.pagination": + x.Pagination = nil + case "tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.height": + x.Height = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementsResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementsResponse 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_QueryPacketAcknowledgementsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.acknowledgements": + if len(x.Acknowledgements) == 0 { + return protoreflect.ValueOfList(&_QueryPacketAcknowledgementsResponse_1_list{}) + } + listValue := &_QueryPacketAcknowledgementsResponse_1_list{list: &x.Acknowledgements} + return protoreflect.ValueOfList(listValue) + case "tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.pagination": + value := x.Pagination + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.height": + value := x.Height + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementsResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementsResponse 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_QueryPacketAcknowledgementsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.acknowledgements": + lv := value.List() + clv := lv.(*_QueryPacketAcknowledgementsResponse_1_list) + x.Acknowledgements = *clv.list + case "tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.pagination": + x.Pagination = value.Message().Interface().(*v1beta1.PageResponse) + case "tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.height": + x.Height = value.Message().Interface().(*v1.Height) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementsResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementsResponse 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_QueryPacketAcknowledgementsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.acknowledgements": + if x.Acknowledgements == nil { + x.Acknowledgements = []*PacketState{} + } + value := &_QueryPacketAcknowledgementsResponse_1_list{list: &x.Acknowledgements} + return protoreflect.ValueOfList(value) + case "tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.pagination": + if x.Pagination == nil { + x.Pagination = new(v1beta1.PageResponse) + } + return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect()) + case "tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.height": + if x.Height == nil { + x.Height = new(v1.Height) + } + return protoreflect.ValueOfMessage(x.Height.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementsResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementsResponse 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_QueryPacketAcknowledgementsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.acknowledgements": + list := []*PacketState{} + return protoreflect.ValueOfList(&_QueryPacketAcknowledgementsResponse_1_list{list: &list}) + case "tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.pagination": + m := new(v1beta1.PageResponse) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.height": + m := new(v1.Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryPacketAcknowledgementsResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryPacketAcknowledgementsResponse 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_QueryPacketAcknowledgementsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.QueryPacketAcknowledgementsResponse", 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_QueryPacketAcknowledgementsResponse) 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_QueryPacketAcknowledgementsResponse) 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_QueryPacketAcknowledgementsResponse) 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_QueryPacketAcknowledgementsResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryPacketAcknowledgementsResponse) + 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.Acknowledgements) > 0 { + for _, e := range x.Acknowledgements { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.Pagination != nil { + l = options.Size(x.Pagination) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Height != nil { + l = options.Size(x.Height) + 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().(*QueryPacketAcknowledgementsResponse) + 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.Height != nil { + encoded, err := options.Marshal(x.Height) + 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.Pagination != nil { + encoded, err := options.Marshal(x.Pagination) + 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.Acknowledgements) > 0 { + for iNdEx := len(x.Acknowledgements) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.Acknowledgements[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().(*QueryPacketAcknowledgementsResponse) + 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: QueryPacketAcknowledgementsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPacketAcknowledgementsResponse: 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 Acknowledgements", 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.Acknowledgements = append(x.Acknowledgements, &PacketState{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Acknowledgements[len(x.Acknowledgements)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", 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.Pagination == nil { + x.Pagination = &v1beta1.PageResponse{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); 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 Height", 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.Height == nil { + x.Height = &v1.Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Height); 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 = (*_QueryUnreceivedPacketsRequest_3_list)(nil) + +type _QueryUnreceivedPacketsRequest_3_list struct { + list *[]uint64 +} + +func (x *_QueryUnreceivedPacketsRequest_3_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_QueryUnreceivedPacketsRequest_3_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfUint64((*x.list)[i]) +} + +func (x *_QueryUnreceivedPacketsRequest_3_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Uint() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_QueryUnreceivedPacketsRequest_3_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Uint() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_QueryUnreceivedPacketsRequest_3_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message QueryUnreceivedPacketsRequest at list field PacketCommitmentSequences as it is not of Message kind")) +} + +func (x *_QueryUnreceivedPacketsRequest_3_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_QueryUnreceivedPacketsRequest_3_list) NewElement() protoreflect.Value { + v := uint64(0) + return protoreflect.ValueOfUint64(v) +} + +func (x *_QueryUnreceivedPacketsRequest_3_list) IsValid() bool { + return x.list != nil +} + +var ( + md_QueryUnreceivedPacketsRequest protoreflect.MessageDescriptor + fd_QueryUnreceivedPacketsRequest_dest_chain protoreflect.FieldDescriptor + fd_QueryUnreceivedPacketsRequest_source_chain protoreflect.FieldDescriptor + fd_QueryUnreceivedPacketsRequest_packet_commitment_sequences protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_query_proto_init() + md_QueryUnreceivedPacketsRequest = File_tibc_core_packet_v1_query_proto.Messages().ByName("QueryUnreceivedPacketsRequest") + fd_QueryUnreceivedPacketsRequest_dest_chain = md_QueryUnreceivedPacketsRequest.Fields().ByName("dest_chain") + fd_QueryUnreceivedPacketsRequest_source_chain = md_QueryUnreceivedPacketsRequest.Fields().ByName("source_chain") + fd_QueryUnreceivedPacketsRequest_packet_commitment_sequences = md_QueryUnreceivedPacketsRequest.Fields().ByName("packet_commitment_sequences") +} + +var _ protoreflect.Message = (*fastReflection_QueryUnreceivedPacketsRequest)(nil) + +type fastReflection_QueryUnreceivedPacketsRequest QueryUnreceivedPacketsRequest + +func (x *QueryUnreceivedPacketsRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryUnreceivedPacketsRequest)(x) +} + +func (x *QueryUnreceivedPacketsRequest) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[10] + 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_QueryUnreceivedPacketsRequest_messageType fastReflection_QueryUnreceivedPacketsRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryUnreceivedPacketsRequest_messageType{} + +type fastReflection_QueryUnreceivedPacketsRequest_messageType struct{} + +func (x fastReflection_QueryUnreceivedPacketsRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryUnreceivedPacketsRequest)(nil) +} +func (x fastReflection_QueryUnreceivedPacketsRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryUnreceivedPacketsRequest) +} +func (x fastReflection_QueryUnreceivedPacketsRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryUnreceivedPacketsRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryUnreceivedPacketsRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryUnreceivedPacketsRequest +} + +// 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_QueryUnreceivedPacketsRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryUnreceivedPacketsRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryUnreceivedPacketsRequest) New() protoreflect.Message { + return new(fastReflection_QueryUnreceivedPacketsRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryUnreceivedPacketsRequest) Interface() protoreflect.ProtoMessage { + return (*QueryUnreceivedPacketsRequest)(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_QueryUnreceivedPacketsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.DestChain != "" { + value := protoreflect.ValueOfString(x.DestChain) + if !f(fd_QueryUnreceivedPacketsRequest_dest_chain, value) { + return + } + } + if x.SourceChain != "" { + value := protoreflect.ValueOfString(x.SourceChain) + if !f(fd_QueryUnreceivedPacketsRequest_source_chain, value) { + return + } + } + if len(x.PacketCommitmentSequences) != 0 { + value := protoreflect.ValueOfList(&_QueryUnreceivedPacketsRequest_3_list{list: &x.PacketCommitmentSequences}) + if !f(fd_QueryUnreceivedPacketsRequest_packet_commitment_sequences, 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_QueryUnreceivedPacketsRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedPacketsRequest.dest_chain": + return x.DestChain != "" + case "tibc.core.packet.v1.QueryUnreceivedPacketsRequest.source_chain": + return x.SourceChain != "" + case "tibc.core.packet.v1.QueryUnreceivedPacketsRequest.packet_commitment_sequences": + return len(x.PacketCommitmentSequences) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedPacketsRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedPacketsRequest 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_QueryUnreceivedPacketsRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedPacketsRequest.dest_chain": + x.DestChain = "" + case "tibc.core.packet.v1.QueryUnreceivedPacketsRequest.source_chain": + x.SourceChain = "" + case "tibc.core.packet.v1.QueryUnreceivedPacketsRequest.packet_commitment_sequences": + x.PacketCommitmentSequences = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedPacketsRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedPacketsRequest 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_QueryUnreceivedPacketsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedPacketsRequest.dest_chain": + value := x.DestChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.QueryUnreceivedPacketsRequest.source_chain": + value := x.SourceChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.QueryUnreceivedPacketsRequest.packet_commitment_sequences": + if len(x.PacketCommitmentSequences) == 0 { + return protoreflect.ValueOfList(&_QueryUnreceivedPacketsRequest_3_list{}) + } + listValue := &_QueryUnreceivedPacketsRequest_3_list{list: &x.PacketCommitmentSequences} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedPacketsRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedPacketsRequest 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_QueryUnreceivedPacketsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedPacketsRequest.dest_chain": + x.DestChain = value.Interface().(string) + case "tibc.core.packet.v1.QueryUnreceivedPacketsRequest.source_chain": + x.SourceChain = value.Interface().(string) + case "tibc.core.packet.v1.QueryUnreceivedPacketsRequest.packet_commitment_sequences": + lv := value.List() + clv := lv.(*_QueryUnreceivedPacketsRequest_3_list) + x.PacketCommitmentSequences = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedPacketsRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedPacketsRequest 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_QueryUnreceivedPacketsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedPacketsRequest.packet_commitment_sequences": + if x.PacketCommitmentSequences == nil { + x.PacketCommitmentSequences = []uint64{} + } + value := &_QueryUnreceivedPacketsRequest_3_list{list: &x.PacketCommitmentSequences} + return protoreflect.ValueOfList(value) + case "tibc.core.packet.v1.QueryUnreceivedPacketsRequest.dest_chain": + panic(fmt.Errorf("field dest_chain of message tibc.core.packet.v1.QueryUnreceivedPacketsRequest is not mutable")) + case "tibc.core.packet.v1.QueryUnreceivedPacketsRequest.source_chain": + panic(fmt.Errorf("field source_chain of message tibc.core.packet.v1.QueryUnreceivedPacketsRequest is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedPacketsRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedPacketsRequest 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_QueryUnreceivedPacketsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedPacketsRequest.dest_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.QueryUnreceivedPacketsRequest.source_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.QueryUnreceivedPacketsRequest.packet_commitment_sequences": + list := []uint64{} + return protoreflect.ValueOfList(&_QueryUnreceivedPacketsRequest_3_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedPacketsRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedPacketsRequest 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_QueryUnreceivedPacketsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.QueryUnreceivedPacketsRequest", 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_QueryUnreceivedPacketsRequest) 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_QueryUnreceivedPacketsRequest) 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_QueryUnreceivedPacketsRequest) 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_QueryUnreceivedPacketsRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryUnreceivedPacketsRequest) + 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.DestChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.SourceChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.PacketCommitmentSequences) > 0 { + l = 0 + for _, e := range x.PacketCommitmentSequences { + l += runtime.Sov(uint64(e)) + } + n += 1 + runtime.Sov(uint64(l)) + 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().(*QueryUnreceivedPacketsRequest) + 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.PacketCommitmentSequences) > 0 { + var pksize2 int + for _, num := range x.PacketCommitmentSequences { + pksize2 += runtime.Sov(uint64(num)) + } + i -= pksize2 + j1 := i + for _, num := range x.PacketCommitmentSequences { + for num >= 1<<7 { + dAtA[j1] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j1++ + } + dAtA[j1] = uint8(num) + j1++ + } + i = runtime.EncodeVarint(dAtA, i, uint64(pksize2)) + i-- + dAtA[i] = 0x1a + } + if len(x.SourceChain) > 0 { + i -= len(x.SourceChain) + copy(dAtA[i:], x.SourceChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SourceChain))) + i-- + dAtA[i] = 0x12 + } + if len(x.DestChain) > 0 { + i -= len(x.DestChain) + copy(dAtA[i:], x.DestChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestChain))) + 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().(*QueryUnreceivedPacketsRequest) + 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: QueryUnreceivedPacketsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryUnreceivedPacketsRequest: 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 DestChain", 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.DestChain = 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 SourceChain", 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.SourceChain = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType == 0 { + var v 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++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.PacketCommitmentSequences = append(x.PacketCommitmentSequences, v) + } else if wireType == 2 { + var packedLen 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++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + packedLen + 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 + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(x.PacketCommitmentSequences) == 0 { + x.PacketCommitmentSequences = make([]uint64, 0, elementCount) + } + for iNdEx < postIndex { + var v 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++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.PacketCommitmentSequences = append(x.PacketCommitmentSequences, v) + } + } else { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PacketCommitmentSequences", wireType) + } + 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 = (*_QueryUnreceivedPacketsResponse_1_list)(nil) + +type _QueryUnreceivedPacketsResponse_1_list struct { + list *[]uint64 +} + +func (x *_QueryUnreceivedPacketsResponse_1_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_QueryUnreceivedPacketsResponse_1_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfUint64((*x.list)[i]) +} + +func (x *_QueryUnreceivedPacketsResponse_1_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Uint() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_QueryUnreceivedPacketsResponse_1_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Uint() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_QueryUnreceivedPacketsResponse_1_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message QueryUnreceivedPacketsResponse at list field Sequences as it is not of Message kind")) +} + +func (x *_QueryUnreceivedPacketsResponse_1_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_QueryUnreceivedPacketsResponse_1_list) NewElement() protoreflect.Value { + v := uint64(0) + return protoreflect.ValueOfUint64(v) +} + +func (x *_QueryUnreceivedPacketsResponse_1_list) IsValid() bool { + return x.list != nil +} + +var ( + md_QueryUnreceivedPacketsResponse protoreflect.MessageDescriptor + fd_QueryUnreceivedPacketsResponse_sequences protoreflect.FieldDescriptor + fd_QueryUnreceivedPacketsResponse_height protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_query_proto_init() + md_QueryUnreceivedPacketsResponse = File_tibc_core_packet_v1_query_proto.Messages().ByName("QueryUnreceivedPacketsResponse") + fd_QueryUnreceivedPacketsResponse_sequences = md_QueryUnreceivedPacketsResponse.Fields().ByName("sequences") + fd_QueryUnreceivedPacketsResponse_height = md_QueryUnreceivedPacketsResponse.Fields().ByName("height") +} + +var _ protoreflect.Message = (*fastReflection_QueryUnreceivedPacketsResponse)(nil) + +type fastReflection_QueryUnreceivedPacketsResponse QueryUnreceivedPacketsResponse + +func (x *QueryUnreceivedPacketsResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryUnreceivedPacketsResponse)(x) +} + +func (x *QueryUnreceivedPacketsResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryUnreceivedPacketsResponse_messageType fastReflection_QueryUnreceivedPacketsResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryUnreceivedPacketsResponse_messageType{} + +type fastReflection_QueryUnreceivedPacketsResponse_messageType struct{} + +func (x fastReflection_QueryUnreceivedPacketsResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryUnreceivedPacketsResponse)(nil) +} +func (x fastReflection_QueryUnreceivedPacketsResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryUnreceivedPacketsResponse) +} +func (x fastReflection_QueryUnreceivedPacketsResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryUnreceivedPacketsResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryUnreceivedPacketsResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryUnreceivedPacketsResponse +} + +// 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_QueryUnreceivedPacketsResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryUnreceivedPacketsResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryUnreceivedPacketsResponse) New() protoreflect.Message { + return new(fastReflection_QueryUnreceivedPacketsResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryUnreceivedPacketsResponse) Interface() protoreflect.ProtoMessage { + return (*QueryUnreceivedPacketsResponse)(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_QueryUnreceivedPacketsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.Sequences) != 0 { + value := protoreflect.ValueOfList(&_QueryUnreceivedPacketsResponse_1_list{list: &x.Sequences}) + if !f(fd_QueryUnreceivedPacketsResponse_sequences, value) { + return + } + } + if x.Height != nil { + value := protoreflect.ValueOfMessage(x.Height.ProtoReflect()) + if !f(fd_QueryUnreceivedPacketsResponse_height, 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_QueryUnreceivedPacketsResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedPacketsResponse.sequences": + return len(x.Sequences) != 0 + case "tibc.core.packet.v1.QueryUnreceivedPacketsResponse.height": + return x.Height != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedPacketsResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedPacketsResponse 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_QueryUnreceivedPacketsResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedPacketsResponse.sequences": + x.Sequences = nil + case "tibc.core.packet.v1.QueryUnreceivedPacketsResponse.height": + x.Height = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedPacketsResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedPacketsResponse 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_QueryUnreceivedPacketsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedPacketsResponse.sequences": + if len(x.Sequences) == 0 { + return protoreflect.ValueOfList(&_QueryUnreceivedPacketsResponse_1_list{}) + } + listValue := &_QueryUnreceivedPacketsResponse_1_list{list: &x.Sequences} + return protoreflect.ValueOfList(listValue) + case "tibc.core.packet.v1.QueryUnreceivedPacketsResponse.height": + value := x.Height + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedPacketsResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedPacketsResponse 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_QueryUnreceivedPacketsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedPacketsResponse.sequences": + lv := value.List() + clv := lv.(*_QueryUnreceivedPacketsResponse_1_list) + x.Sequences = *clv.list + case "tibc.core.packet.v1.QueryUnreceivedPacketsResponse.height": + x.Height = value.Message().Interface().(*v1.Height) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedPacketsResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedPacketsResponse 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_QueryUnreceivedPacketsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedPacketsResponse.sequences": + if x.Sequences == nil { + x.Sequences = []uint64{} + } + value := &_QueryUnreceivedPacketsResponse_1_list{list: &x.Sequences} + return protoreflect.ValueOfList(value) + case "tibc.core.packet.v1.QueryUnreceivedPacketsResponse.height": + if x.Height == nil { + x.Height = new(v1.Height) + } + return protoreflect.ValueOfMessage(x.Height.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedPacketsResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedPacketsResponse 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_QueryUnreceivedPacketsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedPacketsResponse.sequences": + list := []uint64{} + return protoreflect.ValueOfList(&_QueryUnreceivedPacketsResponse_1_list{list: &list}) + case "tibc.core.packet.v1.QueryUnreceivedPacketsResponse.height": + m := new(v1.Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedPacketsResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedPacketsResponse 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_QueryUnreceivedPacketsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.QueryUnreceivedPacketsResponse", 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_QueryUnreceivedPacketsResponse) 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_QueryUnreceivedPacketsResponse) 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_QueryUnreceivedPacketsResponse) 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_QueryUnreceivedPacketsResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryUnreceivedPacketsResponse) + 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.Sequences) > 0 { + l = 0 + for _, e := range x.Sequences { + l += runtime.Sov(uint64(e)) + } + n += 1 + runtime.Sov(uint64(l)) + l + } + if x.Height != nil { + l = options.Size(x.Height) + 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().(*QueryUnreceivedPacketsResponse) + 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.Height != nil { + encoded, err := options.Marshal(x.Height) + 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.Sequences) > 0 { + var pksize2 int + for _, num := range x.Sequences { + pksize2 += runtime.Sov(uint64(num)) + } + i -= pksize2 + j1 := i + for _, num := range x.Sequences { + for num >= 1<<7 { + dAtA[j1] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j1++ + } + dAtA[j1] = uint8(num) + j1++ + } + i = runtime.EncodeVarint(dAtA, i, uint64(pksize2)) + 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().(*QueryUnreceivedPacketsResponse) + 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: QueryUnreceivedPacketsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryUnreceivedPacketsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 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++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.Sequences = append(x.Sequences, v) + } else if wireType == 2 { + var packedLen 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++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + packedLen + 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 + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(x.Sequences) == 0 { + x.Sequences = make([]uint64, 0, elementCount) + } + for iNdEx < postIndex { + var v 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++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.Sequences = append(x.Sequences, v) + } + } else { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Sequences", wireType) + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Height", 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.Height == nil { + x.Height = &v1.Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Height); 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 = (*_QueryUnreceivedAcksRequest_3_list)(nil) + +type _QueryUnreceivedAcksRequest_3_list struct { + list *[]uint64 +} + +func (x *_QueryUnreceivedAcksRequest_3_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_QueryUnreceivedAcksRequest_3_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfUint64((*x.list)[i]) +} + +func (x *_QueryUnreceivedAcksRequest_3_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Uint() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_QueryUnreceivedAcksRequest_3_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Uint() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_QueryUnreceivedAcksRequest_3_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message QueryUnreceivedAcksRequest at list field PacketAckSequences as it is not of Message kind")) +} + +func (x *_QueryUnreceivedAcksRequest_3_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_QueryUnreceivedAcksRequest_3_list) NewElement() protoreflect.Value { + v := uint64(0) + return protoreflect.ValueOfUint64(v) +} + +func (x *_QueryUnreceivedAcksRequest_3_list) IsValid() bool { + return x.list != nil +} + +var ( + md_QueryUnreceivedAcksRequest protoreflect.MessageDescriptor + fd_QueryUnreceivedAcksRequest_dest_chain protoreflect.FieldDescriptor + fd_QueryUnreceivedAcksRequest_source_chain protoreflect.FieldDescriptor + fd_QueryUnreceivedAcksRequest_packet_ack_sequences protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_query_proto_init() + md_QueryUnreceivedAcksRequest = File_tibc_core_packet_v1_query_proto.Messages().ByName("QueryUnreceivedAcksRequest") + fd_QueryUnreceivedAcksRequest_dest_chain = md_QueryUnreceivedAcksRequest.Fields().ByName("dest_chain") + fd_QueryUnreceivedAcksRequest_source_chain = md_QueryUnreceivedAcksRequest.Fields().ByName("source_chain") + fd_QueryUnreceivedAcksRequest_packet_ack_sequences = md_QueryUnreceivedAcksRequest.Fields().ByName("packet_ack_sequences") +} + +var _ protoreflect.Message = (*fastReflection_QueryUnreceivedAcksRequest)(nil) + +type fastReflection_QueryUnreceivedAcksRequest QueryUnreceivedAcksRequest + +func (x *QueryUnreceivedAcksRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryUnreceivedAcksRequest)(x) +} + +func (x *QueryUnreceivedAcksRequest) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[12] + 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_QueryUnreceivedAcksRequest_messageType fastReflection_QueryUnreceivedAcksRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryUnreceivedAcksRequest_messageType{} + +type fastReflection_QueryUnreceivedAcksRequest_messageType struct{} + +func (x fastReflection_QueryUnreceivedAcksRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryUnreceivedAcksRequest)(nil) +} +func (x fastReflection_QueryUnreceivedAcksRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryUnreceivedAcksRequest) +} +func (x fastReflection_QueryUnreceivedAcksRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryUnreceivedAcksRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryUnreceivedAcksRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryUnreceivedAcksRequest +} + +// 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_QueryUnreceivedAcksRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryUnreceivedAcksRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryUnreceivedAcksRequest) New() protoreflect.Message { + return new(fastReflection_QueryUnreceivedAcksRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryUnreceivedAcksRequest) Interface() protoreflect.ProtoMessage { + return (*QueryUnreceivedAcksRequest)(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_QueryUnreceivedAcksRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.DestChain != "" { + value := protoreflect.ValueOfString(x.DestChain) + if !f(fd_QueryUnreceivedAcksRequest_dest_chain, value) { + return + } + } + if x.SourceChain != "" { + value := protoreflect.ValueOfString(x.SourceChain) + if !f(fd_QueryUnreceivedAcksRequest_source_chain, value) { + return + } + } + if len(x.PacketAckSequences) != 0 { + value := protoreflect.ValueOfList(&_QueryUnreceivedAcksRequest_3_list{list: &x.PacketAckSequences}) + if !f(fd_QueryUnreceivedAcksRequest_packet_ack_sequences, 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_QueryUnreceivedAcksRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedAcksRequest.dest_chain": + return x.DestChain != "" + case "tibc.core.packet.v1.QueryUnreceivedAcksRequest.source_chain": + return x.SourceChain != "" + case "tibc.core.packet.v1.QueryUnreceivedAcksRequest.packet_ack_sequences": + return len(x.PacketAckSequences) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedAcksRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedAcksRequest 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_QueryUnreceivedAcksRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedAcksRequest.dest_chain": + x.DestChain = "" + case "tibc.core.packet.v1.QueryUnreceivedAcksRequest.source_chain": + x.SourceChain = "" + case "tibc.core.packet.v1.QueryUnreceivedAcksRequest.packet_ack_sequences": + x.PacketAckSequences = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedAcksRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedAcksRequest 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_QueryUnreceivedAcksRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedAcksRequest.dest_chain": + value := x.DestChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.QueryUnreceivedAcksRequest.source_chain": + value := x.SourceChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.QueryUnreceivedAcksRequest.packet_ack_sequences": + if len(x.PacketAckSequences) == 0 { + return protoreflect.ValueOfList(&_QueryUnreceivedAcksRequest_3_list{}) + } + listValue := &_QueryUnreceivedAcksRequest_3_list{list: &x.PacketAckSequences} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedAcksRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedAcksRequest 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_QueryUnreceivedAcksRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedAcksRequest.dest_chain": + x.DestChain = value.Interface().(string) + case "tibc.core.packet.v1.QueryUnreceivedAcksRequest.source_chain": + x.SourceChain = value.Interface().(string) + case "tibc.core.packet.v1.QueryUnreceivedAcksRequest.packet_ack_sequences": + lv := value.List() + clv := lv.(*_QueryUnreceivedAcksRequest_3_list) + x.PacketAckSequences = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedAcksRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedAcksRequest 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_QueryUnreceivedAcksRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedAcksRequest.packet_ack_sequences": + if x.PacketAckSequences == nil { + x.PacketAckSequences = []uint64{} + } + value := &_QueryUnreceivedAcksRequest_3_list{list: &x.PacketAckSequences} + return protoreflect.ValueOfList(value) + case "tibc.core.packet.v1.QueryUnreceivedAcksRequest.dest_chain": + panic(fmt.Errorf("field dest_chain of message tibc.core.packet.v1.QueryUnreceivedAcksRequest is not mutable")) + case "tibc.core.packet.v1.QueryUnreceivedAcksRequest.source_chain": + panic(fmt.Errorf("field source_chain of message tibc.core.packet.v1.QueryUnreceivedAcksRequest is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedAcksRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedAcksRequest 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_QueryUnreceivedAcksRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedAcksRequest.dest_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.QueryUnreceivedAcksRequest.source_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.QueryUnreceivedAcksRequest.packet_ack_sequences": + list := []uint64{} + return protoreflect.ValueOfList(&_QueryUnreceivedAcksRequest_3_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedAcksRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedAcksRequest 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_QueryUnreceivedAcksRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.QueryUnreceivedAcksRequest", 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_QueryUnreceivedAcksRequest) 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_QueryUnreceivedAcksRequest) 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_QueryUnreceivedAcksRequest) 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_QueryUnreceivedAcksRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryUnreceivedAcksRequest) + 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.DestChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.SourceChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.PacketAckSequences) > 0 { + l = 0 + for _, e := range x.PacketAckSequences { + l += runtime.Sov(uint64(e)) + } + n += 1 + runtime.Sov(uint64(l)) + 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().(*QueryUnreceivedAcksRequest) + 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.PacketAckSequences) > 0 { + var pksize2 int + for _, num := range x.PacketAckSequences { + pksize2 += runtime.Sov(uint64(num)) + } + i -= pksize2 + j1 := i + for _, num := range x.PacketAckSequences { + for num >= 1<<7 { + dAtA[j1] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j1++ + } + dAtA[j1] = uint8(num) + j1++ + } + i = runtime.EncodeVarint(dAtA, i, uint64(pksize2)) + i-- + dAtA[i] = 0x1a + } + if len(x.SourceChain) > 0 { + i -= len(x.SourceChain) + copy(dAtA[i:], x.SourceChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SourceChain))) + i-- + dAtA[i] = 0x12 + } + if len(x.DestChain) > 0 { + i -= len(x.DestChain) + copy(dAtA[i:], x.DestChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestChain))) + 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().(*QueryUnreceivedAcksRequest) + 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: QueryUnreceivedAcksRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryUnreceivedAcksRequest: 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 DestChain", 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.DestChain = 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 SourceChain", 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.SourceChain = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType == 0 { + var v 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++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.PacketAckSequences = append(x.PacketAckSequences, v) + } else if wireType == 2 { + var packedLen 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++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + packedLen + 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 + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(x.PacketAckSequences) == 0 { + x.PacketAckSequences = make([]uint64, 0, elementCount) + } + for iNdEx < postIndex { + var v 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++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.PacketAckSequences = append(x.PacketAckSequences, v) + } + } else { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PacketAckSequences", wireType) + } + 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 = (*_QueryUnreceivedAcksResponse_1_list)(nil) + +type _QueryUnreceivedAcksResponse_1_list struct { + list *[]uint64 +} + +func (x *_QueryUnreceivedAcksResponse_1_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_QueryUnreceivedAcksResponse_1_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfUint64((*x.list)[i]) +} + +func (x *_QueryUnreceivedAcksResponse_1_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Uint() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_QueryUnreceivedAcksResponse_1_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Uint() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_QueryUnreceivedAcksResponse_1_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message QueryUnreceivedAcksResponse at list field Sequences as it is not of Message kind")) +} + +func (x *_QueryUnreceivedAcksResponse_1_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_QueryUnreceivedAcksResponse_1_list) NewElement() protoreflect.Value { + v := uint64(0) + return protoreflect.ValueOfUint64(v) +} + +func (x *_QueryUnreceivedAcksResponse_1_list) IsValid() bool { + return x.list != nil +} + +var ( + md_QueryUnreceivedAcksResponse protoreflect.MessageDescriptor + fd_QueryUnreceivedAcksResponse_sequences protoreflect.FieldDescriptor + fd_QueryUnreceivedAcksResponse_height protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_query_proto_init() + md_QueryUnreceivedAcksResponse = File_tibc_core_packet_v1_query_proto.Messages().ByName("QueryUnreceivedAcksResponse") + fd_QueryUnreceivedAcksResponse_sequences = md_QueryUnreceivedAcksResponse.Fields().ByName("sequences") + fd_QueryUnreceivedAcksResponse_height = md_QueryUnreceivedAcksResponse.Fields().ByName("height") +} + +var _ protoreflect.Message = (*fastReflection_QueryUnreceivedAcksResponse)(nil) + +type fastReflection_QueryUnreceivedAcksResponse QueryUnreceivedAcksResponse + +func (x *QueryUnreceivedAcksResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryUnreceivedAcksResponse)(x) +} + +func (x *QueryUnreceivedAcksResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[13] + 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_QueryUnreceivedAcksResponse_messageType fastReflection_QueryUnreceivedAcksResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryUnreceivedAcksResponse_messageType{} + +type fastReflection_QueryUnreceivedAcksResponse_messageType struct{} + +func (x fastReflection_QueryUnreceivedAcksResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryUnreceivedAcksResponse)(nil) +} +func (x fastReflection_QueryUnreceivedAcksResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryUnreceivedAcksResponse) +} +func (x fastReflection_QueryUnreceivedAcksResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryUnreceivedAcksResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryUnreceivedAcksResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryUnreceivedAcksResponse +} + +// 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_QueryUnreceivedAcksResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryUnreceivedAcksResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryUnreceivedAcksResponse) New() protoreflect.Message { + return new(fastReflection_QueryUnreceivedAcksResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryUnreceivedAcksResponse) Interface() protoreflect.ProtoMessage { + return (*QueryUnreceivedAcksResponse)(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_QueryUnreceivedAcksResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.Sequences) != 0 { + value := protoreflect.ValueOfList(&_QueryUnreceivedAcksResponse_1_list{list: &x.Sequences}) + if !f(fd_QueryUnreceivedAcksResponse_sequences, value) { + return + } + } + if x.Height != nil { + value := protoreflect.ValueOfMessage(x.Height.ProtoReflect()) + if !f(fd_QueryUnreceivedAcksResponse_height, 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_QueryUnreceivedAcksResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedAcksResponse.sequences": + return len(x.Sequences) != 0 + case "tibc.core.packet.v1.QueryUnreceivedAcksResponse.height": + return x.Height != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedAcksResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedAcksResponse 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_QueryUnreceivedAcksResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedAcksResponse.sequences": + x.Sequences = nil + case "tibc.core.packet.v1.QueryUnreceivedAcksResponse.height": + x.Height = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedAcksResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedAcksResponse 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_QueryUnreceivedAcksResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedAcksResponse.sequences": + if len(x.Sequences) == 0 { + return protoreflect.ValueOfList(&_QueryUnreceivedAcksResponse_1_list{}) + } + listValue := &_QueryUnreceivedAcksResponse_1_list{list: &x.Sequences} + return protoreflect.ValueOfList(listValue) + case "tibc.core.packet.v1.QueryUnreceivedAcksResponse.height": + value := x.Height + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedAcksResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedAcksResponse 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_QueryUnreceivedAcksResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedAcksResponse.sequences": + lv := value.List() + clv := lv.(*_QueryUnreceivedAcksResponse_1_list) + x.Sequences = *clv.list + case "tibc.core.packet.v1.QueryUnreceivedAcksResponse.height": + x.Height = value.Message().Interface().(*v1.Height) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedAcksResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedAcksResponse 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_QueryUnreceivedAcksResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedAcksResponse.sequences": + if x.Sequences == nil { + x.Sequences = []uint64{} + } + value := &_QueryUnreceivedAcksResponse_1_list{list: &x.Sequences} + return protoreflect.ValueOfList(value) + case "tibc.core.packet.v1.QueryUnreceivedAcksResponse.height": + if x.Height == nil { + x.Height = new(v1.Height) + } + return protoreflect.ValueOfMessage(x.Height.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedAcksResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedAcksResponse 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_QueryUnreceivedAcksResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryUnreceivedAcksResponse.sequences": + list := []uint64{} + return protoreflect.ValueOfList(&_QueryUnreceivedAcksResponse_1_list{list: &list}) + case "tibc.core.packet.v1.QueryUnreceivedAcksResponse.height": + m := new(v1.Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryUnreceivedAcksResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryUnreceivedAcksResponse 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_QueryUnreceivedAcksResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.QueryUnreceivedAcksResponse", 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_QueryUnreceivedAcksResponse) 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_QueryUnreceivedAcksResponse) 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_QueryUnreceivedAcksResponse) 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_QueryUnreceivedAcksResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryUnreceivedAcksResponse) + 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.Sequences) > 0 { + l = 0 + for _, e := range x.Sequences { + l += runtime.Sov(uint64(e)) + } + n += 1 + runtime.Sov(uint64(l)) + l + } + if x.Height != nil { + l = options.Size(x.Height) + 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().(*QueryUnreceivedAcksResponse) + 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.Height != nil { + encoded, err := options.Marshal(x.Height) + 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.Sequences) > 0 { + var pksize2 int + for _, num := range x.Sequences { + pksize2 += runtime.Sov(uint64(num)) + } + i -= pksize2 + j1 := i + for _, num := range x.Sequences { + for num >= 1<<7 { + dAtA[j1] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j1++ + } + dAtA[j1] = uint8(num) + j1++ + } + i = runtime.EncodeVarint(dAtA, i, uint64(pksize2)) + 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().(*QueryUnreceivedAcksResponse) + 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: QueryUnreceivedAcksResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryUnreceivedAcksResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 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++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.Sequences = append(x.Sequences, v) + } else if wireType == 2 { + var packedLen 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++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + packedLen + 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 + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(x.Sequences) == 0 { + x.Sequences = make([]uint64, 0, elementCount) + } + for iNdEx < postIndex { + var v 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++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.Sequences = append(x.Sequences, v) + } + } else { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Sequences", wireType) + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Height", 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.Height == nil { + x.Height = &v1.Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Height); 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_QueryCleanPacketCommitmentRequest protoreflect.MessageDescriptor + fd_QueryCleanPacketCommitmentRequest_dest_chain protoreflect.FieldDescriptor + fd_QueryCleanPacketCommitmentRequest_source_chain protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_query_proto_init() + md_QueryCleanPacketCommitmentRequest = File_tibc_core_packet_v1_query_proto.Messages().ByName("QueryCleanPacketCommitmentRequest") + fd_QueryCleanPacketCommitmentRequest_dest_chain = md_QueryCleanPacketCommitmentRequest.Fields().ByName("dest_chain") + fd_QueryCleanPacketCommitmentRequest_source_chain = md_QueryCleanPacketCommitmentRequest.Fields().ByName("source_chain") +} + +var _ protoreflect.Message = (*fastReflection_QueryCleanPacketCommitmentRequest)(nil) + +type fastReflection_QueryCleanPacketCommitmentRequest QueryCleanPacketCommitmentRequest + +func (x *QueryCleanPacketCommitmentRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryCleanPacketCommitmentRequest)(x) +} + +func (x *QueryCleanPacketCommitmentRequest) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[14] + 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_QueryCleanPacketCommitmentRequest_messageType fastReflection_QueryCleanPacketCommitmentRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryCleanPacketCommitmentRequest_messageType{} + +type fastReflection_QueryCleanPacketCommitmentRequest_messageType struct{} + +func (x fastReflection_QueryCleanPacketCommitmentRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryCleanPacketCommitmentRequest)(nil) +} +func (x fastReflection_QueryCleanPacketCommitmentRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryCleanPacketCommitmentRequest) +} +func (x fastReflection_QueryCleanPacketCommitmentRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryCleanPacketCommitmentRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryCleanPacketCommitmentRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryCleanPacketCommitmentRequest +} + +// 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_QueryCleanPacketCommitmentRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryCleanPacketCommitmentRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryCleanPacketCommitmentRequest) New() protoreflect.Message { + return new(fastReflection_QueryCleanPacketCommitmentRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryCleanPacketCommitmentRequest) Interface() protoreflect.ProtoMessage { + return (*QueryCleanPacketCommitmentRequest)(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_QueryCleanPacketCommitmentRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.DestChain != "" { + value := protoreflect.ValueOfString(x.DestChain) + if !f(fd_QueryCleanPacketCommitmentRequest_dest_chain, value) { + return + } + } + if x.SourceChain != "" { + value := protoreflect.ValueOfString(x.SourceChain) + if !f(fd_QueryCleanPacketCommitmentRequest_source_chain, 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_QueryCleanPacketCommitmentRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryCleanPacketCommitmentRequest.dest_chain": + return x.DestChain != "" + case "tibc.core.packet.v1.QueryCleanPacketCommitmentRequest.source_chain": + return x.SourceChain != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryCleanPacketCommitmentRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryCleanPacketCommitmentRequest 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_QueryCleanPacketCommitmentRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryCleanPacketCommitmentRequest.dest_chain": + x.DestChain = "" + case "tibc.core.packet.v1.QueryCleanPacketCommitmentRequest.source_chain": + x.SourceChain = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryCleanPacketCommitmentRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryCleanPacketCommitmentRequest 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_QueryCleanPacketCommitmentRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.QueryCleanPacketCommitmentRequest.dest_chain": + value := x.DestChain + return protoreflect.ValueOfString(value) + case "tibc.core.packet.v1.QueryCleanPacketCommitmentRequest.source_chain": + value := x.SourceChain + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryCleanPacketCommitmentRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryCleanPacketCommitmentRequest 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_QueryCleanPacketCommitmentRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryCleanPacketCommitmentRequest.dest_chain": + x.DestChain = value.Interface().(string) + case "tibc.core.packet.v1.QueryCleanPacketCommitmentRequest.source_chain": + x.SourceChain = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryCleanPacketCommitmentRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryCleanPacketCommitmentRequest 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_QueryCleanPacketCommitmentRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryCleanPacketCommitmentRequest.dest_chain": + panic(fmt.Errorf("field dest_chain of message tibc.core.packet.v1.QueryCleanPacketCommitmentRequest is not mutable")) + case "tibc.core.packet.v1.QueryCleanPacketCommitmentRequest.source_chain": + panic(fmt.Errorf("field source_chain of message tibc.core.packet.v1.QueryCleanPacketCommitmentRequest is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryCleanPacketCommitmentRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryCleanPacketCommitmentRequest 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_QueryCleanPacketCommitmentRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryCleanPacketCommitmentRequest.dest_chain": + return protoreflect.ValueOfString("") + case "tibc.core.packet.v1.QueryCleanPacketCommitmentRequest.source_chain": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryCleanPacketCommitmentRequest")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryCleanPacketCommitmentRequest 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_QueryCleanPacketCommitmentRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.QueryCleanPacketCommitmentRequest", 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_QueryCleanPacketCommitmentRequest) 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_QueryCleanPacketCommitmentRequest) 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_QueryCleanPacketCommitmentRequest) 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_QueryCleanPacketCommitmentRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryCleanPacketCommitmentRequest) + 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.DestChain) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.SourceChain) + 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().(*QueryCleanPacketCommitmentRequest) + 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.SourceChain) > 0 { + i -= len(x.SourceChain) + copy(dAtA[i:], x.SourceChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SourceChain))) + i-- + dAtA[i] = 0x12 + } + if len(x.DestChain) > 0 { + i -= len(x.DestChain) + copy(dAtA[i:], x.DestChain) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestChain))) + 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().(*QueryCleanPacketCommitmentRequest) + 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: QueryCleanPacketCommitmentRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCleanPacketCommitmentRequest: 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 DestChain", 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.DestChain = 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 SourceChain", 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.SourceChain = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_QueryCleanPacketCommitmentResponse protoreflect.MessageDescriptor + fd_QueryCleanPacketCommitmentResponse_commitment protoreflect.FieldDescriptor + fd_QueryCleanPacketCommitmentResponse_proof protoreflect.FieldDescriptor + fd_QueryCleanPacketCommitmentResponse_proof_height protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_query_proto_init() + md_QueryCleanPacketCommitmentResponse = File_tibc_core_packet_v1_query_proto.Messages().ByName("QueryCleanPacketCommitmentResponse") + fd_QueryCleanPacketCommitmentResponse_commitment = md_QueryCleanPacketCommitmentResponse.Fields().ByName("commitment") + fd_QueryCleanPacketCommitmentResponse_proof = md_QueryCleanPacketCommitmentResponse.Fields().ByName("proof") + fd_QueryCleanPacketCommitmentResponse_proof_height = md_QueryCleanPacketCommitmentResponse.Fields().ByName("proof_height") +} + +var _ protoreflect.Message = (*fastReflection_QueryCleanPacketCommitmentResponse)(nil) + +type fastReflection_QueryCleanPacketCommitmentResponse QueryCleanPacketCommitmentResponse + +func (x *QueryCleanPacketCommitmentResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryCleanPacketCommitmentResponse)(x) +} + +func (x *QueryCleanPacketCommitmentResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryCleanPacketCommitmentResponse_messageType fastReflection_QueryCleanPacketCommitmentResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryCleanPacketCommitmentResponse_messageType{} + +type fastReflection_QueryCleanPacketCommitmentResponse_messageType struct{} + +func (x fastReflection_QueryCleanPacketCommitmentResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryCleanPacketCommitmentResponse)(nil) +} +func (x fastReflection_QueryCleanPacketCommitmentResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryCleanPacketCommitmentResponse) +} +func (x fastReflection_QueryCleanPacketCommitmentResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryCleanPacketCommitmentResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryCleanPacketCommitmentResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryCleanPacketCommitmentResponse +} + +// 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_QueryCleanPacketCommitmentResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryCleanPacketCommitmentResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryCleanPacketCommitmentResponse) New() protoreflect.Message { + return new(fastReflection_QueryCleanPacketCommitmentResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryCleanPacketCommitmentResponse) Interface() protoreflect.ProtoMessage { + return (*QueryCleanPacketCommitmentResponse)(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_QueryCleanPacketCommitmentResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.Commitment) != 0 { + value := protoreflect.ValueOfBytes(x.Commitment) + if !f(fd_QueryCleanPacketCommitmentResponse_commitment, value) { + return + } + } + if len(x.Proof) != 0 { + value := protoreflect.ValueOfBytes(x.Proof) + if !f(fd_QueryCleanPacketCommitmentResponse_proof, value) { + return + } + } + if x.ProofHeight != nil { + value := protoreflect.ValueOfMessage(x.ProofHeight.ProtoReflect()) + if !f(fd_QueryCleanPacketCommitmentResponse_proof_height, 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_QueryCleanPacketCommitmentResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryCleanPacketCommitmentResponse.commitment": + return len(x.Commitment) != 0 + case "tibc.core.packet.v1.QueryCleanPacketCommitmentResponse.proof": + return len(x.Proof) != 0 + case "tibc.core.packet.v1.QueryCleanPacketCommitmentResponse.proof_height": + return x.ProofHeight != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryCleanPacketCommitmentResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryCleanPacketCommitmentResponse 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_QueryCleanPacketCommitmentResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryCleanPacketCommitmentResponse.commitment": + x.Commitment = nil + case "tibc.core.packet.v1.QueryCleanPacketCommitmentResponse.proof": + x.Proof = nil + case "tibc.core.packet.v1.QueryCleanPacketCommitmentResponse.proof_height": + x.ProofHeight = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryCleanPacketCommitmentResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryCleanPacketCommitmentResponse 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_QueryCleanPacketCommitmentResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.QueryCleanPacketCommitmentResponse.commitment": + value := x.Commitment + return protoreflect.ValueOfBytes(value) + case "tibc.core.packet.v1.QueryCleanPacketCommitmentResponse.proof": + value := x.Proof + return protoreflect.ValueOfBytes(value) + case "tibc.core.packet.v1.QueryCleanPacketCommitmentResponse.proof_height": + value := x.ProofHeight + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryCleanPacketCommitmentResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryCleanPacketCommitmentResponse 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_QueryCleanPacketCommitmentResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryCleanPacketCommitmentResponse.commitment": + x.Commitment = value.Bytes() + case "tibc.core.packet.v1.QueryCleanPacketCommitmentResponse.proof": + x.Proof = value.Bytes() + case "tibc.core.packet.v1.QueryCleanPacketCommitmentResponse.proof_height": + x.ProofHeight = value.Message().Interface().(*v1.Height) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryCleanPacketCommitmentResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryCleanPacketCommitmentResponse 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_QueryCleanPacketCommitmentResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryCleanPacketCommitmentResponse.proof_height": + if x.ProofHeight == nil { + x.ProofHeight = new(v1.Height) + } + return protoreflect.ValueOfMessage(x.ProofHeight.ProtoReflect()) + case "tibc.core.packet.v1.QueryCleanPacketCommitmentResponse.commitment": + panic(fmt.Errorf("field commitment of message tibc.core.packet.v1.QueryCleanPacketCommitmentResponse is not mutable")) + case "tibc.core.packet.v1.QueryCleanPacketCommitmentResponse.proof": + panic(fmt.Errorf("field proof of message tibc.core.packet.v1.QueryCleanPacketCommitmentResponse is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryCleanPacketCommitmentResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryCleanPacketCommitmentResponse 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_QueryCleanPacketCommitmentResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.QueryCleanPacketCommitmentResponse.commitment": + return protoreflect.ValueOfBytes(nil) + case "tibc.core.packet.v1.QueryCleanPacketCommitmentResponse.proof": + return protoreflect.ValueOfBytes(nil) + case "tibc.core.packet.v1.QueryCleanPacketCommitmentResponse.proof_height": + m := new(v1.Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.QueryCleanPacketCommitmentResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.QueryCleanPacketCommitmentResponse 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_QueryCleanPacketCommitmentResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.QueryCleanPacketCommitmentResponse", 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_QueryCleanPacketCommitmentResponse) 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_QueryCleanPacketCommitmentResponse) 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_QueryCleanPacketCommitmentResponse) 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_QueryCleanPacketCommitmentResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryCleanPacketCommitmentResponse) + 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.Commitment) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Proof) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ProofHeight != nil { + l = options.Size(x.ProofHeight) + 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().(*QueryCleanPacketCommitmentResponse) + 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.ProofHeight != nil { + encoded, err := options.Marshal(x.ProofHeight) + 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.Proof) > 0 { + i -= len(x.Proof) + copy(dAtA[i:], x.Proof) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Proof))) + i-- + dAtA[i] = 0x12 + } + if len(x.Commitment) > 0 { + i -= len(x.Commitment) + copy(dAtA[i:], x.Commitment) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Commitment))) + 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().(*QueryCleanPacketCommitmentResponse) + 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: QueryCleanPacketCommitmentResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCleanPacketCommitmentResponse: 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 Commitment", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Commitment = append(x.Commitment[:0], dAtA[iNdEx:postIndex]...) + if x.Commitment == nil { + x.Commitment = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Proof = append(x.Proof[:0], dAtA[iNdEx:postIndex]...) + if x.Proof == nil { + x.Proof = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", 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.ProofHeight == nil { + x.ProofHeight = &v1.Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ProofHeight); 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: tibc/core/packet/v1/query.proto + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// QueryPacketCommitmentRequest is the request type for the +// QueryPacketCommitment RPC method +type QueryPacketCommitmentRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // dest chain name + DestChain string `protobuf:"bytes,1,opt,name=dest_chain,json=destChain,proto3" json:"dest_chain,omitempty"` + // source chain name + SourceChain string `protobuf:"bytes,2,opt,name=source_chain,json=sourceChain,proto3" json:"source_chain,omitempty"` + // packet sequence + Sequence uint64 `protobuf:"varint,3,opt,name=sequence,proto3" json:"sequence,omitempty"` +} + +func (x *QueryPacketCommitmentRequest) Reset() { + *x = QueryPacketCommitmentRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryPacketCommitmentRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryPacketCommitmentRequest) ProtoMessage() {} + +// Deprecated: Use QueryPacketCommitmentRequest.ProtoReflect.Descriptor instead. +func (*QueryPacketCommitmentRequest) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_query_proto_rawDescGZIP(), []int{0} +} + +func (x *QueryPacketCommitmentRequest) GetDestChain() string { + if x != nil { + return x.DestChain + } + return "" +} + +func (x *QueryPacketCommitmentRequest) GetSourceChain() string { + if x != nil { + return x.SourceChain + } + return "" +} + +func (x *QueryPacketCommitmentRequest) GetSequence() uint64 { + if x != nil { + return x.Sequence + } + return 0 +} + +// QueryPacketCommitmentResponse defines the client query response for a packet +// which also includes a proof and the height from which the proof was +// retrieved +type QueryPacketCommitmentResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // packet associated with the request fields + Commitment []byte `protobuf:"bytes,1,opt,name=commitment,proto3" json:"commitment,omitempty"` + // merkle proof of existence + Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"` + // height at which the proof was retrieved + ProofHeight *v1.Height `protobuf:"bytes,3,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty"` +} + +func (x *QueryPacketCommitmentResponse) Reset() { + *x = QueryPacketCommitmentResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryPacketCommitmentResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryPacketCommitmentResponse) ProtoMessage() {} + +// Deprecated: Use QueryPacketCommitmentResponse.ProtoReflect.Descriptor instead. +func (*QueryPacketCommitmentResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_query_proto_rawDescGZIP(), []int{1} +} + +func (x *QueryPacketCommitmentResponse) GetCommitment() []byte { + if x != nil { + return x.Commitment + } + return nil +} + +func (x *QueryPacketCommitmentResponse) GetProof() []byte { + if x != nil { + return x.Proof + } + return nil +} + +func (x *QueryPacketCommitmentResponse) GetProofHeight() *v1.Height { + if x != nil { + return x.ProofHeight + } + return nil +} + +// QueryPacketCommitmentsRequest is the request type for the +// Query/QueryPacketCommitments RPC method +type QueryPacketCommitmentsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // dest chain name + DestChain string `protobuf:"bytes,1,opt,name=dest_chain,json=destChain,proto3" json:"dest_chain,omitempty"` + // source chain name + SourceChain string `protobuf:"bytes,2,opt,name=source_chain,json=sourceChain,proto3" json:"source_chain,omitempty"` + // pagination request + Pagination *v1beta1.PageRequest `protobuf:"bytes,3,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (x *QueryPacketCommitmentsRequest) Reset() { + *x = QueryPacketCommitmentsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryPacketCommitmentsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryPacketCommitmentsRequest) ProtoMessage() {} + +// Deprecated: Use QueryPacketCommitmentsRequest.ProtoReflect.Descriptor instead. +func (*QueryPacketCommitmentsRequest) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_query_proto_rawDescGZIP(), []int{2} +} + +func (x *QueryPacketCommitmentsRequest) GetDestChain() string { + if x != nil { + return x.DestChain + } + return "" +} + +func (x *QueryPacketCommitmentsRequest) GetSourceChain() string { + if x != nil { + return x.SourceChain + } + return "" +} + +func (x *QueryPacketCommitmentsRequest) GetPagination() *v1beta1.PageRequest { + if x != nil { + return x.Pagination + } + return nil +} + +// QueryPacketCommitmentsResponse is the request type for the +// Query/QueryPacketCommitments RPC method +type QueryPacketCommitmentsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Commitments []*PacketState `protobuf:"bytes,1,rep,name=commitments,proto3" json:"commitments,omitempty"` + // pagination response + Pagination *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` + // query block height + Height *v1.Height `protobuf:"bytes,3,opt,name=height,proto3" json:"height,omitempty"` +} + +func (x *QueryPacketCommitmentsResponse) Reset() { + *x = QueryPacketCommitmentsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryPacketCommitmentsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryPacketCommitmentsResponse) ProtoMessage() {} + +// Deprecated: Use QueryPacketCommitmentsResponse.ProtoReflect.Descriptor instead. +func (*QueryPacketCommitmentsResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_query_proto_rawDescGZIP(), []int{3} +} + +func (x *QueryPacketCommitmentsResponse) GetCommitments() []*PacketState { + if x != nil { + return x.Commitments + } + return nil +} + +func (x *QueryPacketCommitmentsResponse) GetPagination() *v1beta1.PageResponse { + if x != nil { + return x.Pagination + } + return nil +} + +func (x *QueryPacketCommitmentsResponse) GetHeight() *v1.Height { + if x != nil { + return x.Height + } + return nil +} + +// QueryPacketReceiptRequest is the request type for the +// Query/PacketReceipt RPC method +type QueryPacketReceiptRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // dest chain name + DestChain string `protobuf:"bytes,1,opt,name=dest_chain,json=destChain,proto3" json:"dest_chain,omitempty"` + // source chain name + SourceChain string `protobuf:"bytes,2,opt,name=source_chain,json=sourceChain,proto3" json:"source_chain,omitempty"` + // packet sequence + Sequence uint64 `protobuf:"varint,3,opt,name=sequence,proto3" json:"sequence,omitempty"` +} + +func (x *QueryPacketReceiptRequest) Reset() { + *x = QueryPacketReceiptRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryPacketReceiptRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryPacketReceiptRequest) ProtoMessage() {} + +// Deprecated: Use QueryPacketReceiptRequest.ProtoReflect.Descriptor instead. +func (*QueryPacketReceiptRequest) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_query_proto_rawDescGZIP(), []int{4} +} + +func (x *QueryPacketReceiptRequest) GetDestChain() string { + if x != nil { + return x.DestChain + } + return "" +} + +func (x *QueryPacketReceiptRequest) GetSourceChain() string { + if x != nil { + return x.SourceChain + } + return "" +} + +func (x *QueryPacketReceiptRequest) GetSequence() uint64 { + if x != nil { + return x.Sequence + } + return 0 +} + +// QueryPacketReceiptResponse defines the client query response for a packet +// receipt which also includes a proof, and the height from which the proof was +// retrieved +type QueryPacketReceiptResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // success flag for if receipt exists + Received bool `protobuf:"varint,2,opt,name=received,proto3" json:"received,omitempty"` + // merkle proof of existence + Proof []byte `protobuf:"bytes,3,opt,name=proof,proto3" json:"proof,omitempty"` + // height at which the proof was retrieved + ProofHeight *v1.Height `protobuf:"bytes,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty"` +} + +func (x *QueryPacketReceiptResponse) Reset() { + *x = QueryPacketReceiptResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryPacketReceiptResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryPacketReceiptResponse) ProtoMessage() {} + +// Deprecated: Use QueryPacketReceiptResponse.ProtoReflect.Descriptor instead. +func (*QueryPacketReceiptResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_query_proto_rawDescGZIP(), []int{5} +} + +func (x *QueryPacketReceiptResponse) GetReceived() bool { + if x != nil { + return x.Received + } + return false +} + +func (x *QueryPacketReceiptResponse) GetProof() []byte { + if x != nil { + return x.Proof + } + return nil +} + +func (x *QueryPacketReceiptResponse) GetProofHeight() *v1.Height { + if x != nil { + return x.ProofHeight + } + return nil +} + +// QueryPacketAcknowledgementRequest is the request type for the +// Query/PacketAcknowledgement RPC method +type QueryPacketAcknowledgementRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // dest chain name + DestChain string `protobuf:"bytes,1,opt,name=dest_chain,json=destChain,proto3" json:"dest_chain,omitempty"` + // source chain name + SourceChain string `protobuf:"bytes,2,opt,name=source_chain,json=sourceChain,proto3" json:"source_chain,omitempty"` + // packet sequence + Sequence uint64 `protobuf:"varint,3,opt,name=sequence,proto3" json:"sequence,omitempty"` +} + +func (x *QueryPacketAcknowledgementRequest) Reset() { + *x = QueryPacketAcknowledgementRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryPacketAcknowledgementRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryPacketAcknowledgementRequest) ProtoMessage() {} + +// Deprecated: Use QueryPacketAcknowledgementRequest.ProtoReflect.Descriptor instead. +func (*QueryPacketAcknowledgementRequest) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_query_proto_rawDescGZIP(), []int{6} +} + +func (x *QueryPacketAcknowledgementRequest) GetDestChain() string { + if x != nil { + return x.DestChain + } + return "" +} + +func (x *QueryPacketAcknowledgementRequest) GetSourceChain() string { + if x != nil { + return x.SourceChain + } + return "" +} + +func (x *QueryPacketAcknowledgementRequest) GetSequence() uint64 { + if x != nil { + return x.Sequence + } + return 0 +} + +// QueryPacketAcknowledgementResponse defines the client query response for a +// packet which also includes a proof and the height from which the +// proof was retrieved +type QueryPacketAcknowledgementResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // packet associated with the request fields + Acknowledgement []byte `protobuf:"bytes,1,opt,name=acknowledgement,proto3" json:"acknowledgement,omitempty"` + // merkle proof of existence + Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"` + // height at which the proof was retrieved + ProofHeight *v1.Height `protobuf:"bytes,3,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty"` +} + +func (x *QueryPacketAcknowledgementResponse) Reset() { + *x = QueryPacketAcknowledgementResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryPacketAcknowledgementResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryPacketAcknowledgementResponse) ProtoMessage() {} + +// Deprecated: Use QueryPacketAcknowledgementResponse.ProtoReflect.Descriptor instead. +func (*QueryPacketAcknowledgementResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_query_proto_rawDescGZIP(), []int{7} +} + +func (x *QueryPacketAcknowledgementResponse) GetAcknowledgement() []byte { + if x != nil { + return x.Acknowledgement + } + return nil +} + +func (x *QueryPacketAcknowledgementResponse) GetProof() []byte { + if x != nil { + return x.Proof + } + return nil +} + +func (x *QueryPacketAcknowledgementResponse) GetProofHeight() *v1.Height { + if x != nil { + return x.ProofHeight + } + return nil +} + +// QueryPacketAcknowledgementsRequest is the request type for the +// Query/QueryPacketCommitments RPC method +type QueryPacketAcknowledgementsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // dest chain name + DestChain string `protobuf:"bytes,1,opt,name=dest_chain,json=destChain,proto3" json:"dest_chain,omitempty"` + // source chain name + SourceChain string `protobuf:"bytes,2,opt,name=source_chain,json=sourceChain,proto3" json:"source_chain,omitempty"` + // pagination request + Pagination *v1beta1.PageRequest `protobuf:"bytes,3,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (x *QueryPacketAcknowledgementsRequest) Reset() { + *x = QueryPacketAcknowledgementsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryPacketAcknowledgementsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryPacketAcknowledgementsRequest) ProtoMessage() {} + +// Deprecated: Use QueryPacketAcknowledgementsRequest.ProtoReflect.Descriptor instead. +func (*QueryPacketAcknowledgementsRequest) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_query_proto_rawDescGZIP(), []int{8} +} + +func (x *QueryPacketAcknowledgementsRequest) GetDestChain() string { + if x != nil { + return x.DestChain + } + return "" +} + +func (x *QueryPacketAcknowledgementsRequest) GetSourceChain() string { + if x != nil { + return x.SourceChain + } + return "" +} + +func (x *QueryPacketAcknowledgementsRequest) GetPagination() *v1beta1.PageRequest { + if x != nil { + return x.Pagination + } + return nil +} + +// QueryPacketAcknowledgemetsResponse is the request type for the +// Query/QueryPacketAcknowledgements RPC method +type QueryPacketAcknowledgementsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Acknowledgements []*PacketState `protobuf:"bytes,1,rep,name=acknowledgements,proto3" json:"acknowledgements,omitempty"` + // pagination response + Pagination *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` + // query block height + Height *v1.Height `protobuf:"bytes,3,opt,name=height,proto3" json:"height,omitempty"` +} + +func (x *QueryPacketAcknowledgementsResponse) Reset() { + *x = QueryPacketAcknowledgementsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryPacketAcknowledgementsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryPacketAcknowledgementsResponse) ProtoMessage() {} + +// Deprecated: Use QueryPacketAcknowledgementsResponse.ProtoReflect.Descriptor instead. +func (*QueryPacketAcknowledgementsResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_query_proto_rawDescGZIP(), []int{9} +} + +func (x *QueryPacketAcknowledgementsResponse) GetAcknowledgements() []*PacketState { + if x != nil { + return x.Acknowledgements + } + return nil +} + +func (x *QueryPacketAcknowledgementsResponse) GetPagination() *v1beta1.PageResponse { + if x != nil { + return x.Pagination + } + return nil +} + +func (x *QueryPacketAcknowledgementsResponse) GetHeight() *v1.Height { + if x != nil { + return x.Height + } + return nil +} + +// QueryUnreceivedPacketsRequest is the request type for the +// Query/UnreceivedPackets RPC method +type QueryUnreceivedPacketsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // dest chain name + DestChain string `protobuf:"bytes,1,opt,name=dest_chain,json=destChain,proto3" json:"dest_chain,omitempty"` + // source chain name + SourceChain string `protobuf:"bytes,2,opt,name=source_chain,json=sourceChain,proto3" json:"source_chain,omitempty"` + // list of packet sequences + PacketCommitmentSequences []uint64 `protobuf:"varint,3,rep,packed,name=packet_commitment_sequences,json=packetCommitmentSequences,proto3" json:"packet_commitment_sequences,omitempty"` +} + +func (x *QueryUnreceivedPacketsRequest) Reset() { + *x = QueryUnreceivedPacketsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryUnreceivedPacketsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryUnreceivedPacketsRequest) ProtoMessage() {} + +// Deprecated: Use QueryUnreceivedPacketsRequest.ProtoReflect.Descriptor instead. +func (*QueryUnreceivedPacketsRequest) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_query_proto_rawDescGZIP(), []int{10} +} + +func (x *QueryUnreceivedPacketsRequest) GetDestChain() string { + if x != nil { + return x.DestChain + } + return "" +} + +func (x *QueryUnreceivedPacketsRequest) GetSourceChain() string { + if x != nil { + return x.SourceChain + } + return "" +} + +func (x *QueryUnreceivedPacketsRequest) GetPacketCommitmentSequences() []uint64 { + if x != nil { + return x.PacketCommitmentSequences + } + return nil +} + +// QueryUnreceivedPacketsResponse is the response type for the +// Query/UnreceivedPacketCommitments RPC method +type QueryUnreceivedPacketsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // list of unreceived packet sequences + Sequences []uint64 `protobuf:"varint,1,rep,packed,name=sequences,proto3" json:"sequences,omitempty"` + // query block height + Height *v1.Height `protobuf:"bytes,2,opt,name=height,proto3" json:"height,omitempty"` +} + +func (x *QueryUnreceivedPacketsResponse) Reset() { + *x = QueryUnreceivedPacketsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryUnreceivedPacketsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryUnreceivedPacketsResponse) ProtoMessage() {} + +// Deprecated: Use QueryUnreceivedPacketsResponse.ProtoReflect.Descriptor instead. +func (*QueryUnreceivedPacketsResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_query_proto_rawDescGZIP(), []int{11} +} + +func (x *QueryUnreceivedPacketsResponse) GetSequences() []uint64 { + if x != nil { + return x.Sequences + } + return nil +} + +func (x *QueryUnreceivedPacketsResponse) GetHeight() *v1.Height { + if x != nil { + return x.Height + } + return nil +} + +// QueryUnreceivedAcks is the request type for the +// Query/UnreceivedAcks RPC method +type QueryUnreceivedAcksRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // dest chain name + DestChain string `protobuf:"bytes,1,opt,name=dest_chain,json=destChain,proto3" json:"dest_chain,omitempty"` + // source chain name + SourceChain string `protobuf:"bytes,2,opt,name=source_chain,json=sourceChain,proto3" json:"source_chain,omitempty"` + // list of acknowledgement sequences + PacketAckSequences []uint64 `protobuf:"varint,3,rep,packed,name=packet_ack_sequences,json=packetAckSequences,proto3" json:"packet_ack_sequences,omitempty"` +} + +func (x *QueryUnreceivedAcksRequest) Reset() { + *x = QueryUnreceivedAcksRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryUnreceivedAcksRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryUnreceivedAcksRequest) ProtoMessage() {} + +// Deprecated: Use QueryUnreceivedAcksRequest.ProtoReflect.Descriptor instead. +func (*QueryUnreceivedAcksRequest) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_query_proto_rawDescGZIP(), []int{12} +} + +func (x *QueryUnreceivedAcksRequest) GetDestChain() string { + if x != nil { + return x.DestChain + } + return "" +} + +func (x *QueryUnreceivedAcksRequest) GetSourceChain() string { + if x != nil { + return x.SourceChain + } + return "" +} + +func (x *QueryUnreceivedAcksRequest) GetPacketAckSequences() []uint64 { + if x != nil { + return x.PacketAckSequences + } + return nil +} + +// QueryUnreceivedAcksResponse is the response type for the +// Query/UnreceivedAcks RPC method +type QueryUnreceivedAcksResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // list of unreceived acknowledgement sequences + Sequences []uint64 `protobuf:"varint,1,rep,packed,name=sequences,proto3" json:"sequences,omitempty"` + // query block height + Height *v1.Height `protobuf:"bytes,2,opt,name=height,proto3" json:"height,omitempty"` +} + +func (x *QueryUnreceivedAcksResponse) Reset() { + *x = QueryUnreceivedAcksResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryUnreceivedAcksResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryUnreceivedAcksResponse) ProtoMessage() {} + +// Deprecated: Use QueryUnreceivedAcksResponse.ProtoReflect.Descriptor instead. +func (*QueryUnreceivedAcksResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_query_proto_rawDescGZIP(), []int{13} +} + +func (x *QueryUnreceivedAcksResponse) GetSequences() []uint64 { + if x != nil { + return x.Sequences + } + return nil +} + +func (x *QueryUnreceivedAcksResponse) GetHeight() *v1.Height { + if x != nil { + return x.Height + } + return nil +} + +// QueryCleanPacketCommitmentRequest is the request type for the +// QueryCleanPacketCommitment RPC method +type QueryCleanPacketCommitmentRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // dest chain name + DestChain string `protobuf:"bytes,1,opt,name=dest_chain,json=destChain,proto3" json:"dest_chain,omitempty"` + // source chain name + SourceChain string `protobuf:"bytes,2,opt,name=source_chain,json=sourceChain,proto3" json:"source_chain,omitempty"` +} + +func (x *QueryCleanPacketCommitmentRequest) Reset() { + *x = QueryCleanPacketCommitmentRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryCleanPacketCommitmentRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryCleanPacketCommitmentRequest) ProtoMessage() {} + +// Deprecated: Use QueryCleanPacketCommitmentRequest.ProtoReflect.Descriptor instead. +func (*QueryCleanPacketCommitmentRequest) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_query_proto_rawDescGZIP(), []int{14} +} + +func (x *QueryCleanPacketCommitmentRequest) GetDestChain() string { + if x != nil { + return x.DestChain + } + return "" +} + +func (x *QueryCleanPacketCommitmentRequest) GetSourceChain() string { + if x != nil { + return x.SourceChain + } + return "" +} + +// QueryCleanPacketCommitmentResponse defines the client query response for a +// packet which also includes a proof and the height from which the proof was +// retrieved +type QueryCleanPacketCommitmentResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // packet associated with the request fields + Commitment []byte `protobuf:"bytes,1,opt,name=commitment,proto3" json:"commitment,omitempty"` + // merkle proof of existence + Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"` + // height at which the proof was retrieved + ProofHeight *v1.Height `protobuf:"bytes,3,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty"` +} + +func (x *QueryCleanPacketCommitmentResponse) Reset() { + *x = QueryCleanPacketCommitmentResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_query_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryCleanPacketCommitmentResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryCleanPacketCommitmentResponse) ProtoMessage() {} + +// Deprecated: Use QueryCleanPacketCommitmentResponse.ProtoReflect.Descriptor instead. +func (*QueryCleanPacketCommitmentResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_query_proto_rawDescGZIP(), []int{15} +} + +func (x *QueryCleanPacketCommitmentResponse) GetCommitment() []byte { + if x != nil { + return x.Commitment + } + return nil +} + +func (x *QueryCleanPacketCommitmentResponse) GetProof() []byte { + if x != nil { + return x.Proof + } + return nil +} + +func (x *QueryCleanPacketCommitmentResponse) GetProofHeight() *v1.Height { + if x != nil { + return x.ProofHeight + } + return nil +} + +var File_tibc_core_packet_v1_query_proto protoreflect.FileDescriptor + +var file_tibc_core_packet_v1_query_proto_rawDesc = []byte{ + 0x0a, 0x1f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x70, 0x61, 0x63, 0x6b, + 0x65, 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x13, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, + 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x1a, 0x20, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, + 0x65, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, + 0x2f, 0x62, 0x61, 0x73, 0x65, 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2f, 0x76, 0x31, 0x62, 0x65, + 0x74, 0x61, 0x31, 0x2f, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, + 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 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, 0x22, 0x7c, 0x0a, 0x1c, 0x51, 0x75, + 0x65, 0x72, 0x79, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, + 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x64, 0x65, + 0x73, 0x74, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x64, 0x65, 0x73, 0x74, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x1a, 0x0a, 0x08, + 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, + 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x22, 0x9b, 0x01, 0x0a, 0x1d, 0x51, 0x75, 0x65, + 0x72, 0x79, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, + 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x6f, + 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, + 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, + 0x6f, 0x6f, 0x66, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x70, 0x72, 0x6f, 0x6f, 0x66, + 0x12, 0x44, 0x0a, 0x0c, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x65, 0x69, + 0x67, 0x68, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0b, 0x70, 0x72, 0x6f, 0x6f, 0x66, + 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0xa9, 0x01, 0x0a, 0x1d, 0x51, 0x75, 0x65, 0x72, 0x79, + 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x64, 0x65, 0x73, 0x74, + 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, 0x65, + 0x73, 0x74, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, + 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, + 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, + 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x22, 0xe8, 0x01, 0x0a, 0x1e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x63, 0x6b, + 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, + 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x74, 0x69, 0x62, + 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, + 0x2e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x0b, 0x63, 0x6f, + 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, + 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, + 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, + 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x39, 0x0a, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, + 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x79, 0x0a, + 0x19, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x52, 0x65, 0x63, 0x65, + 0x69, 0x70, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x64, 0x65, + 0x73, 0x74, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x64, 0x65, 0x73, 0x74, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x1a, 0x0a, 0x08, + 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, + 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x22, 0x94, 0x01, 0x0a, 0x1a, 0x51, 0x75, 0x65, + 0x72, 0x79, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x63, 0x65, 0x69, + 0x76, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65, 0x63, 0x65, 0x69, + 0x76, 0x65, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0c, 0x52, 0x05, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x44, 0x0a, 0x0c, 0x70, 0x72, 0x6f, + 0x6f, 0x66, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1b, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, 0x04, 0xc8, 0xde, + 0x1f, 0x00, 0x52, 0x0b, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, + 0x81, 0x01, 0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x41, + 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x68, + 0x61, 0x69, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, 0x65, 0x73, 0x74, 0x43, + 0x68, 0x61, 0x69, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, + 0x68, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x71, 0x75, 0x65, + 0x6e, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x73, 0x65, 0x71, 0x75, 0x65, + 0x6e, 0x63, 0x65, 0x22, 0xaa, 0x01, 0x0a, 0x22, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x63, + 0x6b, 0x65, 0x74, 0x41, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x6d, 0x65, + 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x28, 0x0a, 0x0f, 0x61, 0x63, + 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x61, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, + 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x05, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x44, 0x0a, 0x0c, 0x70, 0x72, + 0x6f, 0x6f, 0x66, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1b, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, 0x04, 0xc8, + 0xde, 0x1f, 0x00, 0x52, 0x0b, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, + 0x22, 0xae, 0x01, 0x0a, 0x22, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, + 0x41, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x64, 0x65, 0x73, 0x74, 0x5f, + 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, 0x65, 0x73, + 0x74, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, + 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, + 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, + 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x22, 0xf7, 0x01, 0x0a, 0x23, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x63, 0x6b, 0x65, + 0x74, 0x41, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4c, 0x0a, 0x10, 0x61, 0x63, 0x6b, + 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, + 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x10, 0x61, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, + 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, + 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, + 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x39, 0x0a, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1b, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, 0x04, 0xc8, + 0xde, 0x1f, 0x00, 0x52, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0xa1, 0x01, 0x0a, 0x1d, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x55, 0x6e, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x50, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, + 0x0a, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x09, 0x64, 0x65, 0x73, 0x74, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x21, 0x0a, 0x0c, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, + 0x3e, 0x0a, 0x1b, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, + 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x03, + 0x20, 0x03, 0x28, 0x04, 0x52, 0x19, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, + 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x22, + 0x79, 0x0a, 0x1e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x55, 0x6e, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, + 0x65, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x04, 0x52, 0x09, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x12, + 0x39, 0x0a, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1b, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, 0x04, 0xc8, 0xde, + 0x1f, 0x00, 0x52, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x90, 0x01, 0x0a, 0x1a, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x55, 0x6e, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x41, 0x63, + 0x6b, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x64, 0x65, 0x73, + 0x74, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, + 0x65, 0x73, 0x74, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x30, 0x0a, 0x14, 0x70, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x5f, 0x61, 0x63, 0x6b, 0x5f, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, + 0x63, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x04, 0x52, 0x12, 0x70, 0x61, 0x63, 0x6b, 0x65, + 0x74, 0x41, 0x63, 0x6b, 0x53, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x22, 0x76, 0x0a, + 0x1b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x55, 0x6e, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, + 0x41, 0x63, 0x6b, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1c, 0x0a, 0x09, + 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x04, 0x52, + 0x09, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x39, 0x0a, 0x06, 0x68, 0x65, + 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x74, 0x69, 0x62, + 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, + 0x2e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x06, 0x68, + 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x65, 0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, + 0x65, 0x61, 0x6e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, + 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x64, 0x65, + 0x73, 0x74, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x64, 0x65, 0x73, 0x74, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x22, 0xa0, 0x01, 0x0a, + 0x22, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x50, 0x61, 0x63, 0x6b, 0x65, + 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, + 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, + 0x65, 0x6e, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0c, 0x52, 0x05, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x44, 0x0a, 0x0c, 0x70, 0x72, 0x6f, + 0x6f, 0x66, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1b, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, 0x04, 0xc8, 0xde, + 0x1f, 0x00, 0x52, 0x0b, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x32, + 0xee, 0x0f, 0x0a, 0x05, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0xf0, 0x01, 0x0a, 0x10, 0x50, 0x61, + 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x31, + 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, + 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, + 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x32, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, + 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x63, + 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x75, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x6f, 0x12, 0x6d, 0x2f, + 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, + 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, + 0x63, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x2f, 0x7b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, + 0x68, 0x61, 0x69, 0x6e, 0x7d, 0x2f, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, + 0x73, 0x2f, 0x7b, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x7d, 0x2f, 0x70, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, + 0x73, 0x2f, 0x7b, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x7d, 0x12, 0xe8, 0x01, 0x0a, + 0x11, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, + 0x74, 0x73, 0x12, 0x32, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, + 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x33, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, + 0x72, 0x79, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, + 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x6a, 0x82, 0xd3, 0xe4, + 0x93, 0x02, 0x64, 0x12, 0x62, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, + 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x2f, 0x7b, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x7d, 0x2f, 0x64, 0x65, 0x73, 0x74, + 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x2f, 0x7b, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x68, + 0x61, 0x69, 0x6e, 0x7d, 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, + 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0xe4, 0x01, 0x0a, 0x0d, 0x50, 0x61, 0x63, 0x6b, + 0x65, 0x74, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x12, 0x2e, 0x2e, 0x74, 0x69, 0x62, 0x63, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x52, 0x65, 0x63, 0x65, 0x69, + 0x70, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x74, 0x69, 0x62, 0x63, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x52, 0x65, 0x63, 0x65, 0x69, + 0x70, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x72, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x6c, 0x12, 0x6a, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x70, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x2f, 0x7b, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x7d, 0x2f, 0x64, 0x65, 0x73, 0x74, 0x5f, + 0x63, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x2f, 0x7b, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x68, 0x61, + 0x69, 0x6e, 0x7d, 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x5f, 0x72, 0x65, 0x63, 0x65, 0x69, + 0x70, 0x74, 0x73, 0x2f, 0x7b, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x7d, 0x12, 0xf8, + 0x01, 0x0a, 0x15, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x41, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, + 0x65, 0x64, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x36, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x41, 0x63, 0x6b, 0x6e, 0x6f, 0x77, + 0x6c, 0x65, 0x64, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x37, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, + 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x63, 0x6b, + 0x65, 0x74, 0x41, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x6d, 0x65, 0x6e, + 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x6e, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x68, 0x12, 0x66, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x70, 0x61, + 0x63, 0x6b, 0x65, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x2f, 0x7b, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x7d, 0x2f, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x63, + 0x68, 0x61, 0x69, 0x6e, 0x73, 0x2f, 0x7b, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x68, 0x61, 0x69, + 0x6e, 0x7d, 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x5f, 0x61, 0x63, 0x6b, 0x73, 0x2f, 0x7b, + 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x7d, 0x12, 0xfc, 0x01, 0x0a, 0x16, 0x50, 0x61, + 0x63, 0x6b, 0x65, 0x74, 0x41, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x6d, + 0x65, 0x6e, 0x74, 0x73, 0x12, 0x37, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, + 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x41, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, + 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x38, 0x2e, + 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, + 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x41, + 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x6f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x69, 0x12, + 0x67, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x70, 0x61, 0x63, 0x6b, + 0x65, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x2f, 0x7b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x7d, 0x2f, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x68, 0x61, + 0x69, 0x6e, 0x73, 0x2f, 0x7b, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x7d, + 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x5f, 0x61, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, + 0x64, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x9c, 0x02, 0x0a, 0x11, 0x55, 0x6e, 0x72, + 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x12, 0x32, + 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, + 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x55, 0x6e, 0x72, 0x65, 0x63, 0x65, + 0x69, 0x76, 0x65, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x33, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x55, 0x6e, + 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x9d, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x96, + 0x01, 0x12, 0x93, 0x01, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x70, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x2f, 0x7b, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x7d, 0x2f, 0x64, 0x65, 0x73, 0x74, 0x5f, + 0x63, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x2f, 0x7b, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x68, 0x61, + 0x69, 0x6e, 0x7d, 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, + 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x7b, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x5f, 0x63, + 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, + 0x63, 0x65, 0x73, 0x7d, 0x2f, 0x75, 0x6e, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x5f, + 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x12, 0x89, 0x02, 0x0a, 0x0e, 0x55, 0x6e, 0x72, 0x65, + 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x41, 0x63, 0x6b, 0x73, 0x12, 0x2f, 0x2e, 0x74, 0x69, 0x62, + 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, + 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x55, 0x6e, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, + 0x41, 0x63, 0x6b, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x30, 0x2e, 0x74, 0x69, + 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, + 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x55, 0x6e, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, + 0x64, 0x41, 0x63, 0x6b, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x93, 0x01, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x8c, 0x01, 0x12, 0x89, 0x01, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, + 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, + 0x74, 0x61, 0x31, 0x2f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, + 0x73, 0x2f, 0x7b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x7d, + 0x2f, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x2f, 0x7b, 0x64, 0x65, + 0x73, 0x74, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x7d, 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, + 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x7b, 0x70, 0x61, + 0x63, 0x6b, 0x65, 0x74, 0x5f, 0x61, 0x63, 0x6b, 0x5f, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, + 0x65, 0x73, 0x7d, 0x2f, 0x75, 0x6e, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x5f, 0x61, + 0x63, 0x6b, 0x73, 0x12, 0xfa, 0x01, 0x0a, 0x15, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x50, 0x61, 0x63, + 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x36, 0x2e, + 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, + 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x50, 0x61, + 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x37, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, + 0x79, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, + 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x70, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x6a, 0x12, 0x68, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, + 0x72, 0x65, 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, + 0x31, 0x2f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x2f, + 0x7b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x7d, 0x2f, 0x64, + 0x65, 0x73, 0x74, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x2f, 0x7b, 0x64, 0x65, 0x73, 0x74, + 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x7d, 0x2f, 0x63, 0x6c, 0x65, 0x61, 0x6e, 0x5f, 0x70, 0x61, + 0x63, 0x6b, 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, + 0x42, 0xd3, 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x42, 0x0a, 0x51, 0x75, + 0x65, 0x72, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3d, 0x67, 0x69, 0x74, 0x68, + 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, + 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2d, 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x74, 0x69, 0x62, + 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2f, 0x76, 0x31, + 0x3b, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x54, 0x43, 0x50, 0xaa, + 0x02, 0x13, 0x54, 0x69, 0x62, 0x63, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0x2e, 0x50, 0x61, 0x63, 0x6b, + 0x65, 0x74, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x13, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x43, 0x6f, 0x72, + 0x65, 0x5c, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x1f, 0x54, 0x69, + 0x62, 0x63, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x5c, 0x56, + 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x16, + 0x54, 0x69, 0x62, 0x63, 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x3a, 0x3a, 0x50, 0x61, 0x63, 0x6b, + 0x65, 0x74, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_core_packet_v1_query_proto_rawDescOnce sync.Once + file_tibc_core_packet_v1_query_proto_rawDescData = file_tibc_core_packet_v1_query_proto_rawDesc +) + +func file_tibc_core_packet_v1_query_proto_rawDescGZIP() []byte { + file_tibc_core_packet_v1_query_proto_rawDescOnce.Do(func() { + file_tibc_core_packet_v1_query_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_core_packet_v1_query_proto_rawDescData) + }) + return file_tibc_core_packet_v1_query_proto_rawDescData +} + +var file_tibc_core_packet_v1_query_proto_msgTypes = make([]protoimpl.MessageInfo, 16) +var file_tibc_core_packet_v1_query_proto_goTypes = []interface{}{ + (*QueryPacketCommitmentRequest)(nil), // 0: tibc.core.packet.v1.QueryPacketCommitmentRequest + (*QueryPacketCommitmentResponse)(nil), // 1: tibc.core.packet.v1.QueryPacketCommitmentResponse + (*QueryPacketCommitmentsRequest)(nil), // 2: tibc.core.packet.v1.QueryPacketCommitmentsRequest + (*QueryPacketCommitmentsResponse)(nil), // 3: tibc.core.packet.v1.QueryPacketCommitmentsResponse + (*QueryPacketReceiptRequest)(nil), // 4: tibc.core.packet.v1.QueryPacketReceiptRequest + (*QueryPacketReceiptResponse)(nil), // 5: tibc.core.packet.v1.QueryPacketReceiptResponse + (*QueryPacketAcknowledgementRequest)(nil), // 6: tibc.core.packet.v1.QueryPacketAcknowledgementRequest + (*QueryPacketAcknowledgementResponse)(nil), // 7: tibc.core.packet.v1.QueryPacketAcknowledgementResponse + (*QueryPacketAcknowledgementsRequest)(nil), // 8: tibc.core.packet.v1.QueryPacketAcknowledgementsRequest + (*QueryPacketAcknowledgementsResponse)(nil), // 9: tibc.core.packet.v1.QueryPacketAcknowledgementsResponse + (*QueryUnreceivedPacketsRequest)(nil), // 10: tibc.core.packet.v1.QueryUnreceivedPacketsRequest + (*QueryUnreceivedPacketsResponse)(nil), // 11: tibc.core.packet.v1.QueryUnreceivedPacketsResponse + (*QueryUnreceivedAcksRequest)(nil), // 12: tibc.core.packet.v1.QueryUnreceivedAcksRequest + (*QueryUnreceivedAcksResponse)(nil), // 13: tibc.core.packet.v1.QueryUnreceivedAcksResponse + (*QueryCleanPacketCommitmentRequest)(nil), // 14: tibc.core.packet.v1.QueryCleanPacketCommitmentRequest + (*QueryCleanPacketCommitmentResponse)(nil), // 15: tibc.core.packet.v1.QueryCleanPacketCommitmentResponse + (*v1.Height)(nil), // 16: tibc.core.client.v1.Height + (*v1beta1.PageRequest)(nil), // 17: cosmos.base.query.v1beta1.PageRequest + (*PacketState)(nil), // 18: tibc.core.packet.v1.PacketState + (*v1beta1.PageResponse)(nil), // 19: cosmos.base.query.v1beta1.PageResponse +} +var file_tibc_core_packet_v1_query_proto_depIdxs = []int32{ + 16, // 0: tibc.core.packet.v1.QueryPacketCommitmentResponse.proof_height:type_name -> tibc.core.client.v1.Height + 17, // 1: tibc.core.packet.v1.QueryPacketCommitmentsRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest + 18, // 2: tibc.core.packet.v1.QueryPacketCommitmentsResponse.commitments:type_name -> tibc.core.packet.v1.PacketState + 19, // 3: tibc.core.packet.v1.QueryPacketCommitmentsResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse + 16, // 4: tibc.core.packet.v1.QueryPacketCommitmentsResponse.height:type_name -> tibc.core.client.v1.Height + 16, // 5: tibc.core.packet.v1.QueryPacketReceiptResponse.proof_height:type_name -> tibc.core.client.v1.Height + 16, // 6: tibc.core.packet.v1.QueryPacketAcknowledgementResponse.proof_height:type_name -> tibc.core.client.v1.Height + 17, // 7: tibc.core.packet.v1.QueryPacketAcknowledgementsRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest + 18, // 8: tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.acknowledgements:type_name -> tibc.core.packet.v1.PacketState + 19, // 9: tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse + 16, // 10: tibc.core.packet.v1.QueryPacketAcknowledgementsResponse.height:type_name -> tibc.core.client.v1.Height + 16, // 11: tibc.core.packet.v1.QueryUnreceivedPacketsResponse.height:type_name -> tibc.core.client.v1.Height + 16, // 12: tibc.core.packet.v1.QueryUnreceivedAcksResponse.height:type_name -> tibc.core.client.v1.Height + 16, // 13: tibc.core.packet.v1.QueryCleanPacketCommitmentResponse.proof_height:type_name -> tibc.core.client.v1.Height + 0, // 14: tibc.core.packet.v1.Query.PacketCommitment:input_type -> tibc.core.packet.v1.QueryPacketCommitmentRequest + 2, // 15: tibc.core.packet.v1.Query.PacketCommitments:input_type -> tibc.core.packet.v1.QueryPacketCommitmentsRequest + 4, // 16: tibc.core.packet.v1.Query.PacketReceipt:input_type -> tibc.core.packet.v1.QueryPacketReceiptRequest + 6, // 17: tibc.core.packet.v1.Query.PacketAcknowledgement:input_type -> tibc.core.packet.v1.QueryPacketAcknowledgementRequest + 8, // 18: tibc.core.packet.v1.Query.PacketAcknowledgements:input_type -> tibc.core.packet.v1.QueryPacketAcknowledgementsRequest + 10, // 19: tibc.core.packet.v1.Query.UnreceivedPackets:input_type -> tibc.core.packet.v1.QueryUnreceivedPacketsRequest + 12, // 20: tibc.core.packet.v1.Query.UnreceivedAcks:input_type -> tibc.core.packet.v1.QueryUnreceivedAcksRequest + 14, // 21: tibc.core.packet.v1.Query.CleanPacketCommitment:input_type -> tibc.core.packet.v1.QueryCleanPacketCommitmentRequest + 1, // 22: tibc.core.packet.v1.Query.PacketCommitment:output_type -> tibc.core.packet.v1.QueryPacketCommitmentResponse + 3, // 23: tibc.core.packet.v1.Query.PacketCommitments:output_type -> tibc.core.packet.v1.QueryPacketCommitmentsResponse + 5, // 24: tibc.core.packet.v1.Query.PacketReceipt:output_type -> tibc.core.packet.v1.QueryPacketReceiptResponse + 7, // 25: tibc.core.packet.v1.Query.PacketAcknowledgement:output_type -> tibc.core.packet.v1.QueryPacketAcknowledgementResponse + 9, // 26: tibc.core.packet.v1.Query.PacketAcknowledgements:output_type -> tibc.core.packet.v1.QueryPacketAcknowledgementsResponse + 11, // 27: tibc.core.packet.v1.Query.UnreceivedPackets:output_type -> tibc.core.packet.v1.QueryUnreceivedPacketsResponse + 13, // 28: tibc.core.packet.v1.Query.UnreceivedAcks:output_type -> tibc.core.packet.v1.QueryUnreceivedAcksResponse + 15, // 29: tibc.core.packet.v1.Query.CleanPacketCommitment:output_type -> tibc.core.packet.v1.QueryCleanPacketCommitmentResponse + 22, // [22:30] is the sub-list for method output_type + 14, // [14:22] is the sub-list for method input_type + 14, // [14:14] is the sub-list for extension type_name + 14, // [14:14] is the sub-list for extension extendee + 0, // [0:14] is the sub-list for field type_name +} + +func init() { file_tibc_core_packet_v1_query_proto_init() } +func file_tibc_core_packet_v1_query_proto_init() { + if File_tibc_core_packet_v1_query_proto != nil { + return + } + file_tibc_core_packet_v1_packet_proto_init() + if !protoimpl.UnsafeEnabled { + file_tibc_core_packet_v1_query_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryPacketCommitmentRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_query_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryPacketCommitmentResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_query_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryPacketCommitmentsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_query_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryPacketCommitmentsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_query_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryPacketReceiptRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_query_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryPacketReceiptResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_query_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryPacketAcknowledgementRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_query_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryPacketAcknowledgementResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_query_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryPacketAcknowledgementsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_query_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryPacketAcknowledgementsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_query_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryUnreceivedPacketsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_query_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryUnreceivedPacketsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_query_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryUnreceivedAcksRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_query_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryUnreceivedAcksResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_query_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryCleanPacketCommitmentRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_query_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryCleanPacketCommitmentResponse); 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_tibc_core_packet_v1_query_proto_rawDesc, + NumEnums: 0, + NumMessages: 16, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_tibc_core_packet_v1_query_proto_goTypes, + DependencyIndexes: file_tibc_core_packet_v1_query_proto_depIdxs, + MessageInfos: file_tibc_core_packet_v1_query_proto_msgTypes, + }.Build() + File_tibc_core_packet_v1_query_proto = out.File + file_tibc_core_packet_v1_query_proto_rawDesc = nil + file_tibc_core_packet_v1_query_proto_goTypes = nil + file_tibc_core_packet_v1_query_proto_depIdxs = nil +} diff --git a/api/tibc/core/packet/v1/query_grpc.pb.go b/api/tibc/core/packet/v1/query_grpc.pb.go new file mode 100644 index 00000000..fc32d807 --- /dev/null +++ b/api/tibc/core/packet/v1/query_grpc.pb.go @@ -0,0 +1,390 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: tibc/core/packet/v1/query.proto + +package packetv1 + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + Query_PacketCommitment_FullMethodName = "/tibc.core.packet.v1.Query/PacketCommitment" + Query_PacketCommitments_FullMethodName = "/tibc.core.packet.v1.Query/PacketCommitments" + Query_PacketReceipt_FullMethodName = "/tibc.core.packet.v1.Query/PacketReceipt" + Query_PacketAcknowledgement_FullMethodName = "/tibc.core.packet.v1.Query/PacketAcknowledgement" + Query_PacketAcknowledgements_FullMethodName = "/tibc.core.packet.v1.Query/PacketAcknowledgements" + Query_UnreceivedPackets_FullMethodName = "/tibc.core.packet.v1.Query/UnreceivedPackets" + Query_UnreceivedAcks_FullMethodName = "/tibc.core.packet.v1.Query/UnreceivedAcks" + Query_CleanPacketCommitment_FullMethodName = "/tibc.core.packet.v1.Query/CleanPacketCommitment" +) + +// QueryClient is the client API for Query service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type QueryClient interface { + // PacketCommitment queries a stored packet commitment hash. + PacketCommitment(ctx context.Context, in *QueryPacketCommitmentRequest, opts ...grpc.CallOption) (*QueryPacketCommitmentResponse, error) + // PacketCommitments returns all the packet commitments hashes associated + PacketCommitments(ctx context.Context, in *QueryPacketCommitmentsRequest, opts ...grpc.CallOption) (*QueryPacketCommitmentsResponse, error) + // PacketReceipt queries if a given packet sequence has been received on the + // queried chain + PacketReceipt(ctx context.Context, in *QueryPacketReceiptRequest, opts ...grpc.CallOption) (*QueryPacketReceiptResponse, error) + // PacketAcknowledgement queries a stored packet acknowledgement hash. + PacketAcknowledgement(ctx context.Context, in *QueryPacketAcknowledgementRequest, opts ...grpc.CallOption) (*QueryPacketAcknowledgementResponse, error) + // PacketAcknowledgements returns all the packet acknowledgements associated + PacketAcknowledgements(ctx context.Context, in *QueryPacketAcknowledgementsRequest, opts ...grpc.CallOption) (*QueryPacketAcknowledgementsResponse, error) + // UnreceivedPackets returns all the unreceived TIBC packets associated with + // sequences. + UnreceivedPackets(ctx context.Context, in *QueryUnreceivedPacketsRequest, opts ...grpc.CallOption) (*QueryUnreceivedPacketsResponse, error) + // UnreceivedAcks returns all the unreceived TIBC acknowledgements associated + // with sequences. + UnreceivedAcks(ctx context.Context, in *QueryUnreceivedAcksRequest, opts ...grpc.CallOption) (*QueryUnreceivedAcksResponse, error) + // CleanPacketCommitment queries a stored packet commitment hash. + CleanPacketCommitment(ctx context.Context, in *QueryCleanPacketCommitmentRequest, opts ...grpc.CallOption) (*QueryCleanPacketCommitmentResponse, error) +} + +type queryClient struct { + cc grpc.ClientConnInterface +} + +func NewQueryClient(cc grpc.ClientConnInterface) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) PacketCommitment(ctx context.Context, in *QueryPacketCommitmentRequest, opts ...grpc.CallOption) (*QueryPacketCommitmentResponse, error) { + out := new(QueryPacketCommitmentResponse) + err := c.cc.Invoke(ctx, Query_PacketCommitment_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) PacketCommitments(ctx context.Context, in *QueryPacketCommitmentsRequest, opts ...grpc.CallOption) (*QueryPacketCommitmentsResponse, error) { + out := new(QueryPacketCommitmentsResponse) + err := c.cc.Invoke(ctx, Query_PacketCommitments_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) PacketReceipt(ctx context.Context, in *QueryPacketReceiptRequest, opts ...grpc.CallOption) (*QueryPacketReceiptResponse, error) { + out := new(QueryPacketReceiptResponse) + err := c.cc.Invoke(ctx, Query_PacketReceipt_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) PacketAcknowledgement(ctx context.Context, in *QueryPacketAcknowledgementRequest, opts ...grpc.CallOption) (*QueryPacketAcknowledgementResponse, error) { + out := new(QueryPacketAcknowledgementResponse) + err := c.cc.Invoke(ctx, Query_PacketAcknowledgement_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) PacketAcknowledgements(ctx context.Context, in *QueryPacketAcknowledgementsRequest, opts ...grpc.CallOption) (*QueryPacketAcknowledgementsResponse, error) { + out := new(QueryPacketAcknowledgementsResponse) + err := c.cc.Invoke(ctx, Query_PacketAcknowledgements_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) UnreceivedPackets(ctx context.Context, in *QueryUnreceivedPacketsRequest, opts ...grpc.CallOption) (*QueryUnreceivedPacketsResponse, error) { + out := new(QueryUnreceivedPacketsResponse) + err := c.cc.Invoke(ctx, Query_UnreceivedPackets_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) UnreceivedAcks(ctx context.Context, in *QueryUnreceivedAcksRequest, opts ...grpc.CallOption) (*QueryUnreceivedAcksResponse, error) { + out := new(QueryUnreceivedAcksResponse) + err := c.cc.Invoke(ctx, Query_UnreceivedAcks_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) CleanPacketCommitment(ctx context.Context, in *QueryCleanPacketCommitmentRequest, opts ...grpc.CallOption) (*QueryCleanPacketCommitmentResponse, error) { + out := new(QueryCleanPacketCommitmentResponse) + err := c.cc.Invoke(ctx, Query_CleanPacketCommitment_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +// All implementations must embed UnimplementedQueryServer +// for forward compatibility +type QueryServer interface { + // PacketCommitment queries a stored packet commitment hash. + PacketCommitment(context.Context, *QueryPacketCommitmentRequest) (*QueryPacketCommitmentResponse, error) + // PacketCommitments returns all the packet commitments hashes associated + PacketCommitments(context.Context, *QueryPacketCommitmentsRequest) (*QueryPacketCommitmentsResponse, error) + // PacketReceipt queries if a given packet sequence has been received on the + // queried chain + PacketReceipt(context.Context, *QueryPacketReceiptRequest) (*QueryPacketReceiptResponse, error) + // PacketAcknowledgement queries a stored packet acknowledgement hash. + PacketAcknowledgement(context.Context, *QueryPacketAcknowledgementRequest) (*QueryPacketAcknowledgementResponse, error) + // PacketAcknowledgements returns all the packet acknowledgements associated + PacketAcknowledgements(context.Context, *QueryPacketAcknowledgementsRequest) (*QueryPacketAcknowledgementsResponse, error) + // UnreceivedPackets returns all the unreceived TIBC packets associated with + // sequences. + UnreceivedPackets(context.Context, *QueryUnreceivedPacketsRequest) (*QueryUnreceivedPacketsResponse, error) + // UnreceivedAcks returns all the unreceived TIBC acknowledgements associated + // with sequences. + UnreceivedAcks(context.Context, *QueryUnreceivedAcksRequest) (*QueryUnreceivedAcksResponse, error) + // CleanPacketCommitment queries a stored packet commitment hash. + CleanPacketCommitment(context.Context, *QueryCleanPacketCommitmentRequest) (*QueryCleanPacketCommitmentResponse, error) + mustEmbedUnimplementedQueryServer() +} + +// UnimplementedQueryServer must be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct { +} + +func (UnimplementedQueryServer) PacketCommitment(context.Context, *QueryPacketCommitmentRequest) (*QueryPacketCommitmentResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method PacketCommitment not implemented") +} +func (UnimplementedQueryServer) PacketCommitments(context.Context, *QueryPacketCommitmentsRequest) (*QueryPacketCommitmentsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method PacketCommitments not implemented") +} +func (UnimplementedQueryServer) PacketReceipt(context.Context, *QueryPacketReceiptRequest) (*QueryPacketReceiptResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method PacketReceipt not implemented") +} +func (UnimplementedQueryServer) PacketAcknowledgement(context.Context, *QueryPacketAcknowledgementRequest) (*QueryPacketAcknowledgementResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method PacketAcknowledgement not implemented") +} +func (UnimplementedQueryServer) PacketAcknowledgements(context.Context, *QueryPacketAcknowledgementsRequest) (*QueryPacketAcknowledgementsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method PacketAcknowledgements not implemented") +} +func (UnimplementedQueryServer) UnreceivedPackets(context.Context, *QueryUnreceivedPacketsRequest) (*QueryUnreceivedPacketsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UnreceivedPackets not implemented") +} +func (UnimplementedQueryServer) UnreceivedAcks(context.Context, *QueryUnreceivedAcksRequest) (*QueryUnreceivedAcksResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UnreceivedAcks not implemented") +} +func (UnimplementedQueryServer) CleanPacketCommitment(context.Context, *QueryCleanPacketCommitmentRequest) (*QueryCleanPacketCommitmentResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CleanPacketCommitment not implemented") +} +func (UnimplementedQueryServer) mustEmbedUnimplementedQueryServer() {} + +// UnsafeQueryServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to QueryServer will +// result in compilation errors. +type UnsafeQueryServer interface { + mustEmbedUnimplementedQueryServer() +} + +func RegisterQueryServer(s grpc.ServiceRegistrar, srv QueryServer) { + s.RegisterService(&Query_ServiceDesc, srv) +} + +func _Query_PacketCommitment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryPacketCommitmentRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).PacketCommitment(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_PacketCommitment_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).PacketCommitment(ctx, req.(*QueryPacketCommitmentRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_PacketCommitments_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryPacketCommitmentsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).PacketCommitments(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_PacketCommitments_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).PacketCommitments(ctx, req.(*QueryPacketCommitmentsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_PacketReceipt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryPacketReceiptRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).PacketReceipt(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_PacketReceipt_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).PacketReceipt(ctx, req.(*QueryPacketReceiptRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_PacketAcknowledgement_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryPacketAcknowledgementRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).PacketAcknowledgement(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_PacketAcknowledgement_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).PacketAcknowledgement(ctx, req.(*QueryPacketAcknowledgementRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_PacketAcknowledgements_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryPacketAcknowledgementsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).PacketAcknowledgements(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_PacketAcknowledgements_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).PacketAcknowledgements(ctx, req.(*QueryPacketAcknowledgementsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_UnreceivedPackets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryUnreceivedPacketsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).UnreceivedPackets(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_UnreceivedPackets_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).UnreceivedPackets(ctx, req.(*QueryUnreceivedPacketsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_UnreceivedAcks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryUnreceivedAcksRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).UnreceivedAcks(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_UnreceivedAcks_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).UnreceivedAcks(ctx, req.(*QueryUnreceivedAcksRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_CleanPacketCommitment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryCleanPacketCommitmentRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).CleanPacketCommitment(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_CleanPacketCommitment_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).CleanPacketCommitment(ctx, req.(*QueryCleanPacketCommitmentRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// Query_ServiceDesc is the grpc.ServiceDesc for Query service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Query_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "tibc.core.packet.v1.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "PacketCommitment", + Handler: _Query_PacketCommitment_Handler, + }, + { + MethodName: "PacketCommitments", + Handler: _Query_PacketCommitments_Handler, + }, + { + MethodName: "PacketReceipt", + Handler: _Query_PacketReceipt_Handler, + }, + { + MethodName: "PacketAcknowledgement", + Handler: _Query_PacketAcknowledgement_Handler, + }, + { + MethodName: "PacketAcknowledgements", + Handler: _Query_PacketAcknowledgements_Handler, + }, + { + MethodName: "UnreceivedPackets", + Handler: _Query_UnreceivedPackets_Handler, + }, + { + MethodName: "UnreceivedAcks", + Handler: _Query_UnreceivedAcks_Handler, + }, + { + MethodName: "CleanPacketCommitment", + Handler: _Query_CleanPacketCommitment_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "tibc/core/packet/v1/query.proto", +} diff --git a/api/tibc/core/packet/v1/tx.pulsar.go b/api/tibc/core/packet/v1/tx.pulsar.go new file mode 100644 index 00000000..2d5804db --- /dev/null +++ b/api/tibc/core/packet/v1/tx.pulsar.go @@ -0,0 +1,4586 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package packetv1 + +import ( + fmt "fmt" + v1 "github.com/bianjieai/tibc-go/api/tibc/core/client/v1" + 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" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_MsgRecvPacket protoreflect.MessageDescriptor + fd_MsgRecvPacket_packet protoreflect.FieldDescriptor + fd_MsgRecvPacket_proof_commitment protoreflect.FieldDescriptor + fd_MsgRecvPacket_proof_height protoreflect.FieldDescriptor + fd_MsgRecvPacket_signer protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_tx_proto_init() + md_MsgRecvPacket = File_tibc_core_packet_v1_tx_proto.Messages().ByName("MsgRecvPacket") + fd_MsgRecvPacket_packet = md_MsgRecvPacket.Fields().ByName("packet") + fd_MsgRecvPacket_proof_commitment = md_MsgRecvPacket.Fields().ByName("proof_commitment") + fd_MsgRecvPacket_proof_height = md_MsgRecvPacket.Fields().ByName("proof_height") + fd_MsgRecvPacket_signer = md_MsgRecvPacket.Fields().ByName("signer") +} + +var _ protoreflect.Message = (*fastReflection_MsgRecvPacket)(nil) + +type fastReflection_MsgRecvPacket MsgRecvPacket + +func (x *MsgRecvPacket) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgRecvPacket)(x) +} + +func (x *MsgRecvPacket) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_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_MsgRecvPacket_messageType fastReflection_MsgRecvPacket_messageType +var _ protoreflect.MessageType = fastReflection_MsgRecvPacket_messageType{} + +type fastReflection_MsgRecvPacket_messageType struct{} + +func (x fastReflection_MsgRecvPacket_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgRecvPacket)(nil) +} +func (x fastReflection_MsgRecvPacket_messageType) New() protoreflect.Message { + return new(fastReflection_MsgRecvPacket) +} +func (x fastReflection_MsgRecvPacket_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgRecvPacket +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgRecvPacket) Descriptor() protoreflect.MessageDescriptor { + return md_MsgRecvPacket +} + +// 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_MsgRecvPacket) Type() protoreflect.MessageType { + return _fastReflection_MsgRecvPacket_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgRecvPacket) New() protoreflect.Message { + return new(fastReflection_MsgRecvPacket) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgRecvPacket) Interface() protoreflect.ProtoMessage { + return (*MsgRecvPacket)(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_MsgRecvPacket) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Packet != nil { + value := protoreflect.ValueOfMessage(x.Packet.ProtoReflect()) + if !f(fd_MsgRecvPacket_packet, value) { + return + } + } + if len(x.ProofCommitment) != 0 { + value := protoreflect.ValueOfBytes(x.ProofCommitment) + if !f(fd_MsgRecvPacket_proof_commitment, value) { + return + } + } + if x.ProofHeight != nil { + value := protoreflect.ValueOfMessage(x.ProofHeight.ProtoReflect()) + if !f(fd_MsgRecvPacket_proof_height, value) { + return + } + } + if x.Signer != "" { + value := protoreflect.ValueOfString(x.Signer) + if !f(fd_MsgRecvPacket_signer, 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_MsgRecvPacket) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.MsgRecvPacket.packet": + return x.Packet != nil + case "tibc.core.packet.v1.MsgRecvPacket.proof_commitment": + return len(x.ProofCommitment) != 0 + case "tibc.core.packet.v1.MsgRecvPacket.proof_height": + return x.ProofHeight != nil + case "tibc.core.packet.v1.MsgRecvPacket.signer": + return x.Signer != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvPacket 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_MsgRecvPacket) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.MsgRecvPacket.packet": + x.Packet = nil + case "tibc.core.packet.v1.MsgRecvPacket.proof_commitment": + x.ProofCommitment = nil + case "tibc.core.packet.v1.MsgRecvPacket.proof_height": + x.ProofHeight = nil + case "tibc.core.packet.v1.MsgRecvPacket.signer": + x.Signer = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvPacket 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_MsgRecvPacket) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.MsgRecvPacket.packet": + value := x.Packet + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.packet.v1.MsgRecvPacket.proof_commitment": + value := x.ProofCommitment + return protoreflect.ValueOfBytes(value) + case "tibc.core.packet.v1.MsgRecvPacket.proof_height": + value := x.ProofHeight + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.packet.v1.MsgRecvPacket.signer": + value := x.Signer + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvPacket 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_MsgRecvPacket) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.MsgRecvPacket.packet": + x.Packet = value.Message().Interface().(*Packet) + case "tibc.core.packet.v1.MsgRecvPacket.proof_commitment": + x.ProofCommitment = value.Bytes() + case "tibc.core.packet.v1.MsgRecvPacket.proof_height": + x.ProofHeight = value.Message().Interface().(*v1.Height) + case "tibc.core.packet.v1.MsgRecvPacket.signer": + x.Signer = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvPacket 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_MsgRecvPacket) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.MsgRecvPacket.packet": + if x.Packet == nil { + x.Packet = new(Packet) + } + return protoreflect.ValueOfMessage(x.Packet.ProtoReflect()) + case "tibc.core.packet.v1.MsgRecvPacket.proof_height": + if x.ProofHeight == nil { + x.ProofHeight = new(v1.Height) + } + return protoreflect.ValueOfMessage(x.ProofHeight.ProtoReflect()) + case "tibc.core.packet.v1.MsgRecvPacket.proof_commitment": + panic(fmt.Errorf("field proof_commitment of message tibc.core.packet.v1.MsgRecvPacket is not mutable")) + case "tibc.core.packet.v1.MsgRecvPacket.signer": + panic(fmt.Errorf("field signer of message tibc.core.packet.v1.MsgRecvPacket is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvPacket 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_MsgRecvPacket) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.MsgRecvPacket.packet": + m := new(Packet) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.packet.v1.MsgRecvPacket.proof_commitment": + return protoreflect.ValueOfBytes(nil) + case "tibc.core.packet.v1.MsgRecvPacket.proof_height": + m := new(v1.Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.packet.v1.MsgRecvPacket.signer": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvPacket 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_MsgRecvPacket) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.MsgRecvPacket", 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_MsgRecvPacket) 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_MsgRecvPacket) 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_MsgRecvPacket) 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_MsgRecvPacket) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgRecvPacket) + 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.Packet != nil { + l = options.Size(x.Packet) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.ProofCommitment) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ProofHeight != nil { + l = options.Size(x.ProofHeight) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Signer) + 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().(*MsgRecvPacket) + 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.Signer) > 0 { + i -= len(x.Signer) + copy(dAtA[i:], x.Signer) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Signer))) + i-- + dAtA[i] = 0x22 + } + if x.ProofHeight != nil { + encoded, err := options.Marshal(x.ProofHeight) + 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.ProofCommitment) > 0 { + i -= len(x.ProofCommitment) + copy(dAtA[i:], x.ProofCommitment) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ProofCommitment))) + i-- + dAtA[i] = 0x12 + } + if x.Packet != nil { + encoded, err := options.Marshal(x.Packet) + 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().(*MsgRecvPacket) + 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: MsgRecvPacket: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRecvPacket: 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 Packet", 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.Packet == nil { + x.Packet = &Packet{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Packet); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProofCommitment", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.ProofCommitment = append(x.ProofCommitment[:0], dAtA[iNdEx:postIndex]...) + if x.ProofCommitment == nil { + x.ProofCommitment = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", 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.ProofHeight == nil { + x.ProofHeight = &v1.Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ProofHeight); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Signer", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Signer = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + 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_MsgRecvPacketResponse protoreflect.MessageDescriptor +) + +func init() { + file_tibc_core_packet_v1_tx_proto_init() + md_MsgRecvPacketResponse = File_tibc_core_packet_v1_tx_proto.Messages().ByName("MsgRecvPacketResponse") +} + +var _ protoreflect.Message = (*fastReflection_MsgRecvPacketResponse)(nil) + +type fastReflection_MsgRecvPacketResponse MsgRecvPacketResponse + +func (x *MsgRecvPacketResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgRecvPacketResponse)(x) +} + +func (x *MsgRecvPacketResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_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_MsgRecvPacketResponse_messageType fastReflection_MsgRecvPacketResponse_messageType +var _ protoreflect.MessageType = fastReflection_MsgRecvPacketResponse_messageType{} + +type fastReflection_MsgRecvPacketResponse_messageType struct{} + +func (x fastReflection_MsgRecvPacketResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgRecvPacketResponse)(nil) +} +func (x fastReflection_MsgRecvPacketResponse_messageType) New() protoreflect.Message { + return new(fastReflection_MsgRecvPacketResponse) +} +func (x fastReflection_MsgRecvPacketResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgRecvPacketResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgRecvPacketResponse) Descriptor() protoreflect.MessageDescriptor { + return md_MsgRecvPacketResponse +} + +// 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_MsgRecvPacketResponse) Type() protoreflect.MessageType { + return _fastReflection_MsgRecvPacketResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgRecvPacketResponse) New() protoreflect.Message { + return new(fastReflection_MsgRecvPacketResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgRecvPacketResponse) Interface() protoreflect.ProtoMessage { + return (*MsgRecvPacketResponse)(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_MsgRecvPacketResponse) 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_MsgRecvPacketResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvPacketResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvPacketResponse 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_MsgRecvPacketResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvPacketResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvPacketResponse 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_MsgRecvPacketResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvPacketResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvPacketResponse 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_MsgRecvPacketResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvPacketResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvPacketResponse 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_MsgRecvPacketResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvPacketResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvPacketResponse 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_MsgRecvPacketResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvPacketResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvPacketResponse 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_MsgRecvPacketResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.MsgRecvPacketResponse", 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_MsgRecvPacketResponse) 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_MsgRecvPacketResponse) 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_MsgRecvPacketResponse) 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_MsgRecvPacketResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgRecvPacketResponse) + 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().(*MsgRecvPacketResponse) + 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().(*MsgRecvPacketResponse) + 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: MsgRecvPacketResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRecvPacketResponse: 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_MsgAcknowledgement protoreflect.MessageDescriptor + fd_MsgAcknowledgement_packet protoreflect.FieldDescriptor + fd_MsgAcknowledgement_acknowledgement protoreflect.FieldDescriptor + fd_MsgAcknowledgement_proof_acked protoreflect.FieldDescriptor + fd_MsgAcknowledgement_proof_height protoreflect.FieldDescriptor + fd_MsgAcknowledgement_signer protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_tx_proto_init() + md_MsgAcknowledgement = File_tibc_core_packet_v1_tx_proto.Messages().ByName("MsgAcknowledgement") + fd_MsgAcknowledgement_packet = md_MsgAcknowledgement.Fields().ByName("packet") + fd_MsgAcknowledgement_acknowledgement = md_MsgAcknowledgement.Fields().ByName("acknowledgement") + fd_MsgAcknowledgement_proof_acked = md_MsgAcknowledgement.Fields().ByName("proof_acked") + fd_MsgAcknowledgement_proof_height = md_MsgAcknowledgement.Fields().ByName("proof_height") + fd_MsgAcknowledgement_signer = md_MsgAcknowledgement.Fields().ByName("signer") +} + +var _ protoreflect.Message = (*fastReflection_MsgAcknowledgement)(nil) + +type fastReflection_MsgAcknowledgement MsgAcknowledgement + +func (x *MsgAcknowledgement) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgAcknowledgement)(x) +} + +func (x *MsgAcknowledgement) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_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_MsgAcknowledgement_messageType fastReflection_MsgAcknowledgement_messageType +var _ protoreflect.MessageType = fastReflection_MsgAcknowledgement_messageType{} + +type fastReflection_MsgAcknowledgement_messageType struct{} + +func (x fastReflection_MsgAcknowledgement_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgAcknowledgement)(nil) +} +func (x fastReflection_MsgAcknowledgement_messageType) New() protoreflect.Message { + return new(fastReflection_MsgAcknowledgement) +} +func (x fastReflection_MsgAcknowledgement_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgAcknowledgement +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgAcknowledgement) Descriptor() protoreflect.MessageDescriptor { + return md_MsgAcknowledgement +} + +// 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_MsgAcknowledgement) Type() protoreflect.MessageType { + return _fastReflection_MsgAcknowledgement_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgAcknowledgement) New() protoreflect.Message { + return new(fastReflection_MsgAcknowledgement) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgAcknowledgement) Interface() protoreflect.ProtoMessage { + return (*MsgAcknowledgement)(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_MsgAcknowledgement) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Packet != nil { + value := protoreflect.ValueOfMessage(x.Packet.ProtoReflect()) + if !f(fd_MsgAcknowledgement_packet, value) { + return + } + } + if len(x.Acknowledgement) != 0 { + value := protoreflect.ValueOfBytes(x.Acknowledgement) + if !f(fd_MsgAcknowledgement_acknowledgement, value) { + return + } + } + if len(x.ProofAcked) != 0 { + value := protoreflect.ValueOfBytes(x.ProofAcked) + if !f(fd_MsgAcknowledgement_proof_acked, value) { + return + } + } + if x.ProofHeight != nil { + value := protoreflect.ValueOfMessage(x.ProofHeight.ProtoReflect()) + if !f(fd_MsgAcknowledgement_proof_height, value) { + return + } + } + if x.Signer != "" { + value := protoreflect.ValueOfString(x.Signer) + if !f(fd_MsgAcknowledgement_signer, 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_MsgAcknowledgement) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.MsgAcknowledgement.packet": + return x.Packet != nil + case "tibc.core.packet.v1.MsgAcknowledgement.acknowledgement": + return len(x.Acknowledgement) != 0 + case "tibc.core.packet.v1.MsgAcknowledgement.proof_acked": + return len(x.ProofAcked) != 0 + case "tibc.core.packet.v1.MsgAcknowledgement.proof_height": + return x.ProofHeight != nil + case "tibc.core.packet.v1.MsgAcknowledgement.signer": + return x.Signer != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgAcknowledgement")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgAcknowledgement 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_MsgAcknowledgement) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.MsgAcknowledgement.packet": + x.Packet = nil + case "tibc.core.packet.v1.MsgAcknowledgement.acknowledgement": + x.Acknowledgement = nil + case "tibc.core.packet.v1.MsgAcknowledgement.proof_acked": + x.ProofAcked = nil + case "tibc.core.packet.v1.MsgAcknowledgement.proof_height": + x.ProofHeight = nil + case "tibc.core.packet.v1.MsgAcknowledgement.signer": + x.Signer = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgAcknowledgement")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgAcknowledgement 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_MsgAcknowledgement) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.MsgAcknowledgement.packet": + value := x.Packet + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.packet.v1.MsgAcknowledgement.acknowledgement": + value := x.Acknowledgement + return protoreflect.ValueOfBytes(value) + case "tibc.core.packet.v1.MsgAcknowledgement.proof_acked": + value := x.ProofAcked + return protoreflect.ValueOfBytes(value) + case "tibc.core.packet.v1.MsgAcknowledgement.proof_height": + value := x.ProofHeight + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.packet.v1.MsgAcknowledgement.signer": + value := x.Signer + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgAcknowledgement")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgAcknowledgement 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_MsgAcknowledgement) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.MsgAcknowledgement.packet": + x.Packet = value.Message().Interface().(*Packet) + case "tibc.core.packet.v1.MsgAcknowledgement.acknowledgement": + x.Acknowledgement = value.Bytes() + case "tibc.core.packet.v1.MsgAcknowledgement.proof_acked": + x.ProofAcked = value.Bytes() + case "tibc.core.packet.v1.MsgAcknowledgement.proof_height": + x.ProofHeight = value.Message().Interface().(*v1.Height) + case "tibc.core.packet.v1.MsgAcknowledgement.signer": + x.Signer = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgAcknowledgement")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgAcknowledgement 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_MsgAcknowledgement) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.MsgAcknowledgement.packet": + if x.Packet == nil { + x.Packet = new(Packet) + } + return protoreflect.ValueOfMessage(x.Packet.ProtoReflect()) + case "tibc.core.packet.v1.MsgAcknowledgement.proof_height": + if x.ProofHeight == nil { + x.ProofHeight = new(v1.Height) + } + return protoreflect.ValueOfMessage(x.ProofHeight.ProtoReflect()) + case "tibc.core.packet.v1.MsgAcknowledgement.acknowledgement": + panic(fmt.Errorf("field acknowledgement of message tibc.core.packet.v1.MsgAcknowledgement is not mutable")) + case "tibc.core.packet.v1.MsgAcknowledgement.proof_acked": + panic(fmt.Errorf("field proof_acked of message tibc.core.packet.v1.MsgAcknowledgement is not mutable")) + case "tibc.core.packet.v1.MsgAcknowledgement.signer": + panic(fmt.Errorf("field signer of message tibc.core.packet.v1.MsgAcknowledgement is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgAcknowledgement")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgAcknowledgement 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_MsgAcknowledgement) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.MsgAcknowledgement.packet": + m := new(Packet) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.packet.v1.MsgAcknowledgement.acknowledgement": + return protoreflect.ValueOfBytes(nil) + case "tibc.core.packet.v1.MsgAcknowledgement.proof_acked": + return protoreflect.ValueOfBytes(nil) + case "tibc.core.packet.v1.MsgAcknowledgement.proof_height": + m := new(v1.Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.packet.v1.MsgAcknowledgement.signer": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgAcknowledgement")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgAcknowledgement 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_MsgAcknowledgement) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.MsgAcknowledgement", 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_MsgAcknowledgement) 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_MsgAcknowledgement) 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_MsgAcknowledgement) 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_MsgAcknowledgement) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgAcknowledgement) + 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.Packet != nil { + l = options.Size(x.Packet) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Acknowledgement) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.ProofAcked) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ProofHeight != nil { + l = options.Size(x.ProofHeight) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Signer) + 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().(*MsgAcknowledgement) + 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.Signer) > 0 { + i -= len(x.Signer) + copy(dAtA[i:], x.Signer) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Signer))) + i-- + dAtA[i] = 0x2a + } + if x.ProofHeight != nil { + encoded, err := options.Marshal(x.ProofHeight) + 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] = 0x22 + } + if len(x.ProofAcked) > 0 { + i -= len(x.ProofAcked) + copy(dAtA[i:], x.ProofAcked) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ProofAcked))) + i-- + dAtA[i] = 0x1a + } + if len(x.Acknowledgement) > 0 { + i -= len(x.Acknowledgement) + copy(dAtA[i:], x.Acknowledgement) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Acknowledgement))) + i-- + dAtA[i] = 0x12 + } + if x.Packet != nil { + encoded, err := options.Marshal(x.Packet) + 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().(*MsgAcknowledgement) + 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: MsgAcknowledgement: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgAcknowledgement: 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 Packet", 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.Packet == nil { + x.Packet = &Packet{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Packet); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Acknowledgement", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Acknowledgement = append(x.Acknowledgement[:0], dAtA[iNdEx:postIndex]...) + if x.Acknowledgement == nil { + x.Acknowledgement = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProofAcked", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.ProofAcked = append(x.ProofAcked[:0], dAtA[iNdEx:postIndex]...) + if x.ProofAcked == nil { + x.ProofAcked = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", 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.ProofHeight == nil { + x.ProofHeight = &v1.Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ProofHeight); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Signer", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Signer = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + 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_MsgAcknowledgementResponse protoreflect.MessageDescriptor +) + +func init() { + file_tibc_core_packet_v1_tx_proto_init() + md_MsgAcknowledgementResponse = File_tibc_core_packet_v1_tx_proto.Messages().ByName("MsgAcknowledgementResponse") +} + +var _ protoreflect.Message = (*fastReflection_MsgAcknowledgementResponse)(nil) + +type fastReflection_MsgAcknowledgementResponse MsgAcknowledgementResponse + +func (x *MsgAcknowledgementResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgAcknowledgementResponse)(x) +} + +func (x *MsgAcknowledgementResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_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_MsgAcknowledgementResponse_messageType fastReflection_MsgAcknowledgementResponse_messageType +var _ protoreflect.MessageType = fastReflection_MsgAcknowledgementResponse_messageType{} + +type fastReflection_MsgAcknowledgementResponse_messageType struct{} + +func (x fastReflection_MsgAcknowledgementResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgAcknowledgementResponse)(nil) +} +func (x fastReflection_MsgAcknowledgementResponse_messageType) New() protoreflect.Message { + return new(fastReflection_MsgAcknowledgementResponse) +} +func (x fastReflection_MsgAcknowledgementResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgAcknowledgementResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgAcknowledgementResponse) Descriptor() protoreflect.MessageDescriptor { + return md_MsgAcknowledgementResponse +} + +// 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_MsgAcknowledgementResponse) Type() protoreflect.MessageType { + return _fastReflection_MsgAcknowledgementResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgAcknowledgementResponse) New() protoreflect.Message { + return new(fastReflection_MsgAcknowledgementResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgAcknowledgementResponse) Interface() protoreflect.ProtoMessage { + return (*MsgAcknowledgementResponse)(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_MsgAcknowledgementResponse) 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_MsgAcknowledgementResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgAcknowledgementResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgAcknowledgementResponse 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_MsgAcknowledgementResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgAcknowledgementResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgAcknowledgementResponse 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_MsgAcknowledgementResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgAcknowledgementResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgAcknowledgementResponse 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_MsgAcknowledgementResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgAcknowledgementResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgAcknowledgementResponse 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_MsgAcknowledgementResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgAcknowledgementResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgAcknowledgementResponse 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_MsgAcknowledgementResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgAcknowledgementResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgAcknowledgementResponse 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_MsgAcknowledgementResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.MsgAcknowledgementResponse", 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_MsgAcknowledgementResponse) 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_MsgAcknowledgementResponse) 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_MsgAcknowledgementResponse) 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_MsgAcknowledgementResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgAcknowledgementResponse) + 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().(*MsgAcknowledgementResponse) + 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().(*MsgAcknowledgementResponse) + 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: MsgAcknowledgementResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgAcknowledgementResponse: 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_MsgCleanPacket protoreflect.MessageDescriptor + fd_MsgCleanPacket_clean_packet protoreflect.FieldDescriptor + fd_MsgCleanPacket_signer protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_tx_proto_init() + md_MsgCleanPacket = File_tibc_core_packet_v1_tx_proto.Messages().ByName("MsgCleanPacket") + fd_MsgCleanPacket_clean_packet = md_MsgCleanPacket.Fields().ByName("clean_packet") + fd_MsgCleanPacket_signer = md_MsgCleanPacket.Fields().ByName("signer") +} + +var _ protoreflect.Message = (*fastReflection_MsgCleanPacket)(nil) + +type fastReflection_MsgCleanPacket MsgCleanPacket + +func (x *MsgCleanPacket) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgCleanPacket)(x) +} + +func (x *MsgCleanPacket) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_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_MsgCleanPacket_messageType fastReflection_MsgCleanPacket_messageType +var _ protoreflect.MessageType = fastReflection_MsgCleanPacket_messageType{} + +type fastReflection_MsgCleanPacket_messageType struct{} + +func (x fastReflection_MsgCleanPacket_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgCleanPacket)(nil) +} +func (x fastReflection_MsgCleanPacket_messageType) New() protoreflect.Message { + return new(fastReflection_MsgCleanPacket) +} +func (x fastReflection_MsgCleanPacket_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgCleanPacket +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgCleanPacket) Descriptor() protoreflect.MessageDescriptor { + return md_MsgCleanPacket +} + +// 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_MsgCleanPacket) Type() protoreflect.MessageType { + return _fastReflection_MsgCleanPacket_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgCleanPacket) New() protoreflect.Message { + return new(fastReflection_MsgCleanPacket) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgCleanPacket) Interface() protoreflect.ProtoMessage { + return (*MsgCleanPacket)(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_MsgCleanPacket) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.CleanPacket != nil { + value := protoreflect.ValueOfMessage(x.CleanPacket.ProtoReflect()) + if !f(fd_MsgCleanPacket_clean_packet, value) { + return + } + } + if x.Signer != "" { + value := protoreflect.ValueOfString(x.Signer) + if !f(fd_MsgCleanPacket_signer, 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_MsgCleanPacket) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.MsgCleanPacket.clean_packet": + return x.CleanPacket != nil + case "tibc.core.packet.v1.MsgCleanPacket.signer": + return x.Signer != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgCleanPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgCleanPacket 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_MsgCleanPacket) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.MsgCleanPacket.clean_packet": + x.CleanPacket = nil + case "tibc.core.packet.v1.MsgCleanPacket.signer": + x.Signer = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgCleanPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgCleanPacket 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_MsgCleanPacket) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.MsgCleanPacket.clean_packet": + value := x.CleanPacket + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.packet.v1.MsgCleanPacket.signer": + value := x.Signer + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgCleanPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgCleanPacket 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_MsgCleanPacket) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.MsgCleanPacket.clean_packet": + x.CleanPacket = value.Message().Interface().(*CleanPacket) + case "tibc.core.packet.v1.MsgCleanPacket.signer": + x.Signer = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgCleanPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgCleanPacket 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_MsgCleanPacket) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.MsgCleanPacket.clean_packet": + if x.CleanPacket == nil { + x.CleanPacket = new(CleanPacket) + } + return protoreflect.ValueOfMessage(x.CleanPacket.ProtoReflect()) + case "tibc.core.packet.v1.MsgCleanPacket.signer": + panic(fmt.Errorf("field signer of message tibc.core.packet.v1.MsgCleanPacket is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgCleanPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgCleanPacket 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_MsgCleanPacket) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.MsgCleanPacket.clean_packet": + m := new(CleanPacket) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.packet.v1.MsgCleanPacket.signer": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgCleanPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgCleanPacket 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_MsgCleanPacket) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.MsgCleanPacket", 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_MsgCleanPacket) 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_MsgCleanPacket) 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_MsgCleanPacket) 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_MsgCleanPacket) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgCleanPacket) + 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.CleanPacket != nil { + l = options.Size(x.CleanPacket) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Signer) + 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().(*MsgCleanPacket) + 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.Signer) > 0 { + i -= len(x.Signer) + copy(dAtA[i:], x.Signer) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Signer))) + i-- + dAtA[i] = 0x12 + } + if x.CleanPacket != nil { + encoded, err := options.Marshal(x.CleanPacket) + 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().(*MsgCleanPacket) + 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: MsgCleanPacket: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCleanPacket: 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 CleanPacket", 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.CleanPacket == nil { + x.CleanPacket = &CleanPacket{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.CleanPacket); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Signer", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Signer = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + 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_MsgCleanPacketResponse protoreflect.MessageDescriptor +) + +func init() { + file_tibc_core_packet_v1_tx_proto_init() + md_MsgCleanPacketResponse = File_tibc_core_packet_v1_tx_proto.Messages().ByName("MsgCleanPacketResponse") +} + +var _ protoreflect.Message = (*fastReflection_MsgCleanPacketResponse)(nil) + +type fastReflection_MsgCleanPacketResponse MsgCleanPacketResponse + +func (x *MsgCleanPacketResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgCleanPacketResponse)(x) +} + +func (x *MsgCleanPacketResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_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_MsgCleanPacketResponse_messageType fastReflection_MsgCleanPacketResponse_messageType +var _ protoreflect.MessageType = fastReflection_MsgCleanPacketResponse_messageType{} + +type fastReflection_MsgCleanPacketResponse_messageType struct{} + +func (x fastReflection_MsgCleanPacketResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgCleanPacketResponse)(nil) +} +func (x fastReflection_MsgCleanPacketResponse_messageType) New() protoreflect.Message { + return new(fastReflection_MsgCleanPacketResponse) +} +func (x fastReflection_MsgCleanPacketResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgCleanPacketResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgCleanPacketResponse) Descriptor() protoreflect.MessageDescriptor { + return md_MsgCleanPacketResponse +} + +// 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_MsgCleanPacketResponse) Type() protoreflect.MessageType { + return _fastReflection_MsgCleanPacketResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgCleanPacketResponse) New() protoreflect.Message { + return new(fastReflection_MsgCleanPacketResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgCleanPacketResponse) Interface() protoreflect.ProtoMessage { + return (*MsgCleanPacketResponse)(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_MsgCleanPacketResponse) 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_MsgCleanPacketResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgCleanPacketResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgCleanPacketResponse 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_MsgCleanPacketResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgCleanPacketResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgCleanPacketResponse 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_MsgCleanPacketResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgCleanPacketResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgCleanPacketResponse 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_MsgCleanPacketResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgCleanPacketResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgCleanPacketResponse 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_MsgCleanPacketResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgCleanPacketResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgCleanPacketResponse 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_MsgCleanPacketResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgCleanPacketResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgCleanPacketResponse 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_MsgCleanPacketResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.MsgCleanPacketResponse", 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_MsgCleanPacketResponse) 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_MsgCleanPacketResponse) 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_MsgCleanPacketResponse) 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_MsgCleanPacketResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgCleanPacketResponse) + 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().(*MsgCleanPacketResponse) + 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().(*MsgCleanPacketResponse) + 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: MsgCleanPacketResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCleanPacketResponse: 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_MsgRecvCleanPacket protoreflect.MessageDescriptor + fd_MsgRecvCleanPacket_clean_packet protoreflect.FieldDescriptor + fd_MsgRecvCleanPacket_proof_commitment protoreflect.FieldDescriptor + fd_MsgRecvCleanPacket_proof_height protoreflect.FieldDescriptor + fd_MsgRecvCleanPacket_signer protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_packet_v1_tx_proto_init() + md_MsgRecvCleanPacket = File_tibc_core_packet_v1_tx_proto.Messages().ByName("MsgRecvCleanPacket") + fd_MsgRecvCleanPacket_clean_packet = md_MsgRecvCleanPacket.Fields().ByName("clean_packet") + fd_MsgRecvCleanPacket_proof_commitment = md_MsgRecvCleanPacket.Fields().ByName("proof_commitment") + fd_MsgRecvCleanPacket_proof_height = md_MsgRecvCleanPacket.Fields().ByName("proof_height") + fd_MsgRecvCleanPacket_signer = md_MsgRecvCleanPacket.Fields().ByName("signer") +} + +var _ protoreflect.Message = (*fastReflection_MsgRecvCleanPacket)(nil) + +type fastReflection_MsgRecvCleanPacket MsgRecvCleanPacket + +func (x *MsgRecvCleanPacket) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgRecvCleanPacket)(x) +} + +func (x *MsgRecvCleanPacket) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_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_MsgRecvCleanPacket_messageType fastReflection_MsgRecvCleanPacket_messageType +var _ protoreflect.MessageType = fastReflection_MsgRecvCleanPacket_messageType{} + +type fastReflection_MsgRecvCleanPacket_messageType struct{} + +func (x fastReflection_MsgRecvCleanPacket_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgRecvCleanPacket)(nil) +} +func (x fastReflection_MsgRecvCleanPacket_messageType) New() protoreflect.Message { + return new(fastReflection_MsgRecvCleanPacket) +} +func (x fastReflection_MsgRecvCleanPacket_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgRecvCleanPacket +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgRecvCleanPacket) Descriptor() protoreflect.MessageDescriptor { + return md_MsgRecvCleanPacket +} + +// 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_MsgRecvCleanPacket) Type() protoreflect.MessageType { + return _fastReflection_MsgRecvCleanPacket_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgRecvCleanPacket) New() protoreflect.Message { + return new(fastReflection_MsgRecvCleanPacket) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgRecvCleanPacket) Interface() protoreflect.ProtoMessage { + return (*MsgRecvCleanPacket)(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_MsgRecvCleanPacket) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.CleanPacket != nil { + value := protoreflect.ValueOfMessage(x.CleanPacket.ProtoReflect()) + if !f(fd_MsgRecvCleanPacket_clean_packet, value) { + return + } + } + if len(x.ProofCommitment) != 0 { + value := protoreflect.ValueOfBytes(x.ProofCommitment) + if !f(fd_MsgRecvCleanPacket_proof_commitment, value) { + return + } + } + if x.ProofHeight != nil { + value := protoreflect.ValueOfMessage(x.ProofHeight.ProtoReflect()) + if !f(fd_MsgRecvCleanPacket_proof_height, value) { + return + } + } + if x.Signer != "" { + value := protoreflect.ValueOfString(x.Signer) + if !f(fd_MsgRecvCleanPacket_signer, 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_MsgRecvCleanPacket) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.packet.v1.MsgRecvCleanPacket.clean_packet": + return x.CleanPacket != nil + case "tibc.core.packet.v1.MsgRecvCleanPacket.proof_commitment": + return len(x.ProofCommitment) != 0 + case "tibc.core.packet.v1.MsgRecvCleanPacket.proof_height": + return x.ProofHeight != nil + case "tibc.core.packet.v1.MsgRecvCleanPacket.signer": + return x.Signer != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvCleanPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvCleanPacket 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_MsgRecvCleanPacket) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.packet.v1.MsgRecvCleanPacket.clean_packet": + x.CleanPacket = nil + case "tibc.core.packet.v1.MsgRecvCleanPacket.proof_commitment": + x.ProofCommitment = nil + case "tibc.core.packet.v1.MsgRecvCleanPacket.proof_height": + x.ProofHeight = nil + case "tibc.core.packet.v1.MsgRecvCleanPacket.signer": + x.Signer = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvCleanPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvCleanPacket 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_MsgRecvCleanPacket) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.packet.v1.MsgRecvCleanPacket.clean_packet": + value := x.CleanPacket + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.packet.v1.MsgRecvCleanPacket.proof_commitment": + value := x.ProofCommitment + return protoreflect.ValueOfBytes(value) + case "tibc.core.packet.v1.MsgRecvCleanPacket.proof_height": + value := x.ProofHeight + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.packet.v1.MsgRecvCleanPacket.signer": + value := x.Signer + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvCleanPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvCleanPacket 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_MsgRecvCleanPacket) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.packet.v1.MsgRecvCleanPacket.clean_packet": + x.CleanPacket = value.Message().Interface().(*CleanPacket) + case "tibc.core.packet.v1.MsgRecvCleanPacket.proof_commitment": + x.ProofCommitment = value.Bytes() + case "tibc.core.packet.v1.MsgRecvCleanPacket.proof_height": + x.ProofHeight = value.Message().Interface().(*v1.Height) + case "tibc.core.packet.v1.MsgRecvCleanPacket.signer": + x.Signer = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvCleanPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvCleanPacket 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_MsgRecvCleanPacket) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.MsgRecvCleanPacket.clean_packet": + if x.CleanPacket == nil { + x.CleanPacket = new(CleanPacket) + } + return protoreflect.ValueOfMessage(x.CleanPacket.ProtoReflect()) + case "tibc.core.packet.v1.MsgRecvCleanPacket.proof_height": + if x.ProofHeight == nil { + x.ProofHeight = new(v1.Height) + } + return protoreflect.ValueOfMessage(x.ProofHeight.ProtoReflect()) + case "tibc.core.packet.v1.MsgRecvCleanPacket.proof_commitment": + panic(fmt.Errorf("field proof_commitment of message tibc.core.packet.v1.MsgRecvCleanPacket is not mutable")) + case "tibc.core.packet.v1.MsgRecvCleanPacket.signer": + panic(fmt.Errorf("field signer of message tibc.core.packet.v1.MsgRecvCleanPacket is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvCleanPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvCleanPacket 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_MsgRecvCleanPacket) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.packet.v1.MsgRecvCleanPacket.clean_packet": + m := new(CleanPacket) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.packet.v1.MsgRecvCleanPacket.proof_commitment": + return protoreflect.ValueOfBytes(nil) + case "tibc.core.packet.v1.MsgRecvCleanPacket.proof_height": + m := new(v1.Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.packet.v1.MsgRecvCleanPacket.signer": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvCleanPacket")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvCleanPacket 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_MsgRecvCleanPacket) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.MsgRecvCleanPacket", 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_MsgRecvCleanPacket) 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_MsgRecvCleanPacket) 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_MsgRecvCleanPacket) 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_MsgRecvCleanPacket) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgRecvCleanPacket) + 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.CleanPacket != nil { + l = options.Size(x.CleanPacket) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.ProofCommitment) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ProofHeight != nil { + l = options.Size(x.ProofHeight) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Signer) + 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().(*MsgRecvCleanPacket) + 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.Signer) > 0 { + i -= len(x.Signer) + copy(dAtA[i:], x.Signer) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Signer))) + i-- + dAtA[i] = 0x22 + } + if x.ProofHeight != nil { + encoded, err := options.Marshal(x.ProofHeight) + 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.ProofCommitment) > 0 { + i -= len(x.ProofCommitment) + copy(dAtA[i:], x.ProofCommitment) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ProofCommitment))) + i-- + dAtA[i] = 0x12 + } + if x.CleanPacket != nil { + encoded, err := options.Marshal(x.CleanPacket) + 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().(*MsgRecvCleanPacket) + 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: MsgRecvCleanPacket: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRecvCleanPacket: 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 CleanPacket", 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.CleanPacket == nil { + x.CleanPacket = &CleanPacket{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.CleanPacket); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProofCommitment", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.ProofCommitment = append(x.ProofCommitment[:0], dAtA[iNdEx:postIndex]...) + if x.ProofCommitment == nil { + x.ProofCommitment = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", 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.ProofHeight == nil { + x.ProofHeight = &v1.Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ProofHeight); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Signer", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Signer = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + 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_MsgRecvCleanPacketResponse protoreflect.MessageDescriptor +) + +func init() { + file_tibc_core_packet_v1_tx_proto_init() + md_MsgRecvCleanPacketResponse = File_tibc_core_packet_v1_tx_proto.Messages().ByName("MsgRecvCleanPacketResponse") +} + +var _ protoreflect.Message = (*fastReflection_MsgRecvCleanPacketResponse)(nil) + +type fastReflection_MsgRecvCleanPacketResponse MsgRecvCleanPacketResponse + +func (x *MsgRecvCleanPacketResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgRecvCleanPacketResponse)(x) +} + +func (x *MsgRecvCleanPacketResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_packet_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_MsgRecvCleanPacketResponse_messageType fastReflection_MsgRecvCleanPacketResponse_messageType +var _ protoreflect.MessageType = fastReflection_MsgRecvCleanPacketResponse_messageType{} + +type fastReflection_MsgRecvCleanPacketResponse_messageType struct{} + +func (x fastReflection_MsgRecvCleanPacketResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgRecvCleanPacketResponse)(nil) +} +func (x fastReflection_MsgRecvCleanPacketResponse_messageType) New() protoreflect.Message { + return new(fastReflection_MsgRecvCleanPacketResponse) +} +func (x fastReflection_MsgRecvCleanPacketResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgRecvCleanPacketResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgRecvCleanPacketResponse) Descriptor() protoreflect.MessageDescriptor { + return md_MsgRecvCleanPacketResponse +} + +// 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_MsgRecvCleanPacketResponse) Type() protoreflect.MessageType { + return _fastReflection_MsgRecvCleanPacketResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgRecvCleanPacketResponse) New() protoreflect.Message { + return new(fastReflection_MsgRecvCleanPacketResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgRecvCleanPacketResponse) Interface() protoreflect.ProtoMessage { + return (*MsgRecvCleanPacketResponse)(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_MsgRecvCleanPacketResponse) 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_MsgRecvCleanPacketResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvCleanPacketResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvCleanPacketResponse 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_MsgRecvCleanPacketResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvCleanPacketResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvCleanPacketResponse 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_MsgRecvCleanPacketResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvCleanPacketResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvCleanPacketResponse 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_MsgRecvCleanPacketResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvCleanPacketResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvCleanPacketResponse 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_MsgRecvCleanPacketResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvCleanPacketResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvCleanPacketResponse 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_MsgRecvCleanPacketResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.packet.v1.MsgRecvCleanPacketResponse")) + } + panic(fmt.Errorf("message tibc.core.packet.v1.MsgRecvCleanPacketResponse 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_MsgRecvCleanPacketResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.packet.v1.MsgRecvCleanPacketResponse", 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_MsgRecvCleanPacketResponse) 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_MsgRecvCleanPacketResponse) 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_MsgRecvCleanPacketResponse) 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_MsgRecvCleanPacketResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgRecvCleanPacketResponse) + 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().(*MsgRecvCleanPacketResponse) + 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().(*MsgRecvCleanPacketResponse) + 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: MsgRecvCleanPacketResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRecvCleanPacketResponse: 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, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: tibc/core/packet/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) +) + +// MsgRecvPacket receives incoming TIBC packet +type MsgRecvPacket struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Packet *Packet `protobuf:"bytes,1,opt,name=packet,proto3" json:"packet,omitempty"` + ProofCommitment []byte `protobuf:"bytes,2,opt,name=proof_commitment,json=proofCommitment,proto3" json:"proof_commitment,omitempty"` + ProofHeight *v1.Height `protobuf:"bytes,3,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty"` + Signer string `protobuf:"bytes,4,opt,name=signer,proto3" json:"signer,omitempty"` +} + +func (x *MsgRecvPacket) Reset() { + *x = MsgRecvPacket{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_tx_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgRecvPacket) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgRecvPacket) ProtoMessage() {} + +// Deprecated: Use MsgRecvPacket.ProtoReflect.Descriptor instead. +func (*MsgRecvPacket) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_tx_proto_rawDescGZIP(), []int{0} +} + +func (x *MsgRecvPacket) GetPacket() *Packet { + if x != nil { + return x.Packet + } + return nil +} + +func (x *MsgRecvPacket) GetProofCommitment() []byte { + if x != nil { + return x.ProofCommitment + } + return nil +} + +func (x *MsgRecvPacket) GetProofHeight() *v1.Height { + if x != nil { + return x.ProofHeight + } + return nil +} + +func (x *MsgRecvPacket) GetSigner() string { + if x != nil { + return x.Signer + } + return "" +} + +// MsgRecvPacketResponse defines the Msg/RecvPacket response type. +type MsgRecvPacketResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *MsgRecvPacketResponse) Reset() { + *x = MsgRecvPacketResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_tx_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgRecvPacketResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgRecvPacketResponse) ProtoMessage() {} + +// Deprecated: Use MsgRecvPacketResponse.ProtoReflect.Descriptor instead. +func (*MsgRecvPacketResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_tx_proto_rawDescGZIP(), []int{1} +} + +// MsgAcknowledgement receives incoming TIBC acknowledgement +type MsgAcknowledgement struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Packet *Packet `protobuf:"bytes,1,opt,name=packet,proto3" json:"packet,omitempty"` + Acknowledgement []byte `protobuf:"bytes,2,opt,name=acknowledgement,proto3" json:"acknowledgement,omitempty"` + ProofAcked []byte `protobuf:"bytes,3,opt,name=proof_acked,json=proofAcked,proto3" json:"proof_acked,omitempty"` + ProofHeight *v1.Height `protobuf:"bytes,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty"` + Signer string `protobuf:"bytes,5,opt,name=signer,proto3" json:"signer,omitempty"` +} + +func (x *MsgAcknowledgement) Reset() { + *x = MsgAcknowledgement{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_tx_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgAcknowledgement) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgAcknowledgement) ProtoMessage() {} + +// Deprecated: Use MsgAcknowledgement.ProtoReflect.Descriptor instead. +func (*MsgAcknowledgement) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_tx_proto_rawDescGZIP(), []int{2} +} + +func (x *MsgAcknowledgement) GetPacket() *Packet { + if x != nil { + return x.Packet + } + return nil +} + +func (x *MsgAcknowledgement) GetAcknowledgement() []byte { + if x != nil { + return x.Acknowledgement + } + return nil +} + +func (x *MsgAcknowledgement) GetProofAcked() []byte { + if x != nil { + return x.ProofAcked + } + return nil +} + +func (x *MsgAcknowledgement) GetProofHeight() *v1.Height { + if x != nil { + return x.ProofHeight + } + return nil +} + +func (x *MsgAcknowledgement) GetSigner() string { + if x != nil { + return x.Signer + } + return "" +} + +// MsgAcknowledgementResponse defines the Msg/Acknowledgement response type. +type MsgAcknowledgementResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *MsgAcknowledgementResponse) Reset() { + *x = MsgAcknowledgementResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_tx_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgAcknowledgementResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgAcknowledgementResponse) ProtoMessage() {} + +// Deprecated: Use MsgAcknowledgementResponse.ProtoReflect.Descriptor instead. +func (*MsgAcknowledgementResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_tx_proto_rawDescGZIP(), []int{3} +} + +// MsgRecvPacket receives incoming TIBC packet +type MsgCleanPacket struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CleanPacket *CleanPacket `protobuf:"bytes,1,opt,name=clean_packet,json=cleanPacket,proto3" json:"clean_packet,omitempty"` + Signer string `protobuf:"bytes,2,opt,name=signer,proto3" json:"signer,omitempty"` +} + +func (x *MsgCleanPacket) Reset() { + *x = MsgCleanPacket{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_tx_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgCleanPacket) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgCleanPacket) ProtoMessage() {} + +// Deprecated: Use MsgCleanPacket.ProtoReflect.Descriptor instead. +func (*MsgCleanPacket) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_tx_proto_rawDescGZIP(), []int{4} +} + +func (x *MsgCleanPacket) GetCleanPacket() *CleanPacket { + if x != nil { + return x.CleanPacket + } + return nil +} + +func (x *MsgCleanPacket) GetSigner() string { + if x != nil { + return x.Signer + } + return "" +} + +// MsgRecvPacketResponse defines the Msg/RecvPacket response type. +type MsgCleanPacketResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *MsgCleanPacketResponse) Reset() { + *x = MsgCleanPacketResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_tx_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgCleanPacketResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgCleanPacketResponse) ProtoMessage() {} + +// Deprecated: Use MsgCleanPacketResponse.ProtoReflect.Descriptor instead. +func (*MsgCleanPacketResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_tx_proto_rawDescGZIP(), []int{5} +} + +// MsgRecvPacket receives incoming TIBC packet +type MsgRecvCleanPacket struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CleanPacket *CleanPacket `protobuf:"bytes,1,opt,name=clean_packet,json=cleanPacket,proto3" json:"clean_packet,omitempty"` + ProofCommitment []byte `protobuf:"bytes,2,opt,name=proof_commitment,json=proofCommitment,proto3" json:"proof_commitment,omitempty"` + ProofHeight *v1.Height `protobuf:"bytes,3,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty"` + Signer string `protobuf:"bytes,4,opt,name=signer,proto3" json:"signer,omitempty"` +} + +func (x *MsgRecvCleanPacket) Reset() { + *x = MsgRecvCleanPacket{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_tx_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgRecvCleanPacket) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgRecvCleanPacket) ProtoMessage() {} + +// Deprecated: Use MsgRecvCleanPacket.ProtoReflect.Descriptor instead. +func (*MsgRecvCleanPacket) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_tx_proto_rawDescGZIP(), []int{6} +} + +func (x *MsgRecvCleanPacket) GetCleanPacket() *CleanPacket { + if x != nil { + return x.CleanPacket + } + return nil +} + +func (x *MsgRecvCleanPacket) GetProofCommitment() []byte { + if x != nil { + return x.ProofCommitment + } + return nil +} + +func (x *MsgRecvCleanPacket) GetProofHeight() *v1.Height { + if x != nil { + return x.ProofHeight + } + return nil +} + +func (x *MsgRecvCleanPacket) GetSigner() string { + if x != nil { + return x.Signer + } + return "" +} + +// MsgRecvPacketResponse defines the Msg/RecvPacket response type. +type MsgRecvCleanPacketResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *MsgRecvCleanPacketResponse) Reset() { + *x = MsgRecvCleanPacketResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_packet_v1_tx_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgRecvCleanPacketResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgRecvCleanPacketResponse) ProtoMessage() {} + +// Deprecated: Use MsgRecvCleanPacketResponse.ProtoReflect.Descriptor instead. +func (*MsgRecvCleanPacketResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_packet_v1_tx_proto_rawDescGZIP(), []int{7} +} + +var File_tibc_core_packet_v1_tx_proto protoreflect.FileDescriptor + +var file_tibc_core_packet_v1_tx_proto_rawDesc = []byte{ + 0x0a, 0x1c, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x70, 0x61, 0x63, 0x6b, + 0x65, 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x74, 0x78, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x13, + 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, + 0x2e, 0x76, 0x31, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, + 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x74, 0x69, 0x62, 0x63, 0x2f, + 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x63, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x74, 0x69, 0x62, + 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2f, 0x76, 0x31, + 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x91, 0x02, + 0x0a, 0x0d, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x63, 0x76, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x12, + 0x39, 0x0a, 0x06, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1b, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, + 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x42, 0x04, 0xc8, 0xde, + 0x1f, 0x00, 0x52, 0x06, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x12, 0x46, 0x0a, 0x10, 0x70, 0x72, + 0x6f, 0x6f, 0x66, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0c, 0x42, 0x1b, 0xf2, 0xde, 0x1f, 0x17, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, + 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, + 0x22, 0x52, 0x0f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, + 0x6e, 0x74, 0x12, 0x5b, 0x0a, 0x0c, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x68, 0x65, 0x69, 0x67, + 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x48, + 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, 0x1b, 0xc8, 0xde, 0x1f, 0x00, 0xf2, 0xde, 0x1f, 0x13, 0x79, + 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, + 0x74, 0x22, 0x52, 0x0b, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, + 0x16, 0x0a, 0x06, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x3a, 0x08, 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, + 0x00, 0x22, 0x17, 0x0a, 0x15, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x63, 0x76, 0x50, 0x61, 0x63, 0x6b, + 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xb1, 0x02, 0x0a, 0x12, 0x4d, + 0x73, 0x67, 0x41, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x6d, 0x65, 0x6e, + 0x74, 0x12, 0x39, 0x0a, 0x06, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1b, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, + 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x42, 0x04, + 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x06, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x0f, + 0x61, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x61, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, + 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x37, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, + 0x61, 0x63, 0x6b, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x16, 0xf2, 0xde, 0x1f, + 0x12, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x61, 0x63, 0x6b, + 0x65, 0x64, 0x22, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x41, 0x63, 0x6b, 0x65, 0x64, 0x12, + 0x5b, 0x0a, 0x0c, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x65, 0x69, 0x67, + 0x68, 0x74, 0x42, 0x1b, 0xc8, 0xde, 0x1f, 0x00, 0xf2, 0xde, 0x1f, 0x13, 0x79, 0x61, 0x6d, 0x6c, + 0x3a, 0x22, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x52, + 0x0b, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x16, 0x0a, 0x06, + 0x73, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x69, + 0x67, 0x6e, 0x65, 0x72, 0x3a, 0x08, 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0x1c, + 0x0a, 0x1a, 0x4d, 0x73, 0x67, 0x41, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, + 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x7d, 0x0a, 0x0e, + 0x4d, 0x73, 0x67, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x12, 0x49, + 0x0a, 0x0c, 0x63, 0x6c, 0x65, 0x61, 0x6e, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x65, 0x61, 0x6e, + 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0b, 0x63, 0x6c, + 0x65, 0x61, 0x6e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x69, 0x67, + 0x6e, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x69, 0x67, 0x6e, 0x65, + 0x72, 0x3a, 0x08, 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0x18, 0x0a, 0x16, 0x4d, + 0x73, 0x67, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xa6, 0x02, 0x0a, 0x12, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x63, + 0x76, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x12, 0x49, 0x0a, 0x0c, + 0x63, 0x6c, 0x65, 0x61, 0x6e, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x50, 0x61, + 0x63, 0x6b, 0x65, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0b, 0x63, 0x6c, 0x65, 0x61, + 0x6e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x12, 0x46, 0x0a, 0x10, 0x70, 0x72, 0x6f, 0x6f, 0x66, + 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0c, 0x42, 0x1b, 0xf2, 0xde, 0x1f, 0x17, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x70, 0x72, 0x6f, + 0x6f, 0x66, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x22, 0x52, 0x0f, + 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x12, + 0x5b, 0x0a, 0x0c, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x65, 0x69, 0x67, + 0x68, 0x74, 0x42, 0x1b, 0xc8, 0xde, 0x1f, 0x00, 0xf2, 0xde, 0x1f, 0x13, 0x79, 0x61, 0x6d, 0x6c, + 0x3a, 0x22, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x52, + 0x0b, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x16, 0x0a, 0x06, + 0x73, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x69, + 0x67, 0x6e, 0x65, 0x72, 0x3a, 0x08, 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0x1c, + 0x0a, 0x1a, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x63, 0x76, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x50, 0x61, + 0x63, 0x6b, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0x9e, 0x03, 0x0a, + 0x03, 0x4d, 0x73, 0x67, 0x12, 0x5c, 0x0a, 0x0a, 0x52, 0x65, 0x63, 0x76, 0x50, 0x61, 0x63, 0x6b, + 0x65, 0x74, 0x12, 0x22, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x63, 0x76, + 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x1a, 0x2a, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, + 0x52, 0x65, 0x63, 0x76, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x6b, 0x0a, 0x0f, 0x41, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, + 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x27, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x41, + 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x1a, 0x2f, + 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, + 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x41, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, + 0x64, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x5f, 0x0a, 0x0b, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x12, 0x23, + 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, + 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x50, 0x61, 0x63, + 0x6b, 0x65, 0x74, 0x1a, 0x2b, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x6c, 0x65, + 0x61, 0x6e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x6b, 0x0a, 0x0f, 0x52, 0x65, 0x63, 0x76, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x50, 0x61, 0x63, + 0x6b, 0x65, 0x74, 0x12, 0x27, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x63, + 0x76, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x1a, 0x2f, 0x2e, 0x74, + 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, + 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x63, 0x76, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x50, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0xd0, 0x01, + 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, + 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, + 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2d, + 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2f, 0x76, 0x31, 0x3b, 0x70, 0x61, 0x63, 0x6b, 0x65, + 0x74, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x54, 0x43, 0x50, 0xaa, 0x02, 0x13, 0x54, 0x69, 0x62, 0x63, + 0x2e, 0x43, 0x6f, 0x72, 0x65, 0x2e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x56, 0x31, 0xca, + 0x02, 0x13, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x50, 0x61, 0x63, 0x6b, + 0x65, 0x74, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x1f, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x43, 0x6f, 0x72, + 0x65, 0x5c, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x16, 0x54, 0x69, 0x62, 0x63, 0x3a, 0x3a, + 0x43, 0x6f, 0x72, 0x65, 0x3a, 0x3a, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x3a, 0x3a, 0x56, 0x31, + 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_core_packet_v1_tx_proto_rawDescOnce sync.Once + file_tibc_core_packet_v1_tx_proto_rawDescData = file_tibc_core_packet_v1_tx_proto_rawDesc +) + +func file_tibc_core_packet_v1_tx_proto_rawDescGZIP() []byte { + file_tibc_core_packet_v1_tx_proto_rawDescOnce.Do(func() { + file_tibc_core_packet_v1_tx_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_core_packet_v1_tx_proto_rawDescData) + }) + return file_tibc_core_packet_v1_tx_proto_rawDescData +} + +var file_tibc_core_packet_v1_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 8) +var file_tibc_core_packet_v1_tx_proto_goTypes = []interface{}{ + (*MsgRecvPacket)(nil), // 0: tibc.core.packet.v1.MsgRecvPacket + (*MsgRecvPacketResponse)(nil), // 1: tibc.core.packet.v1.MsgRecvPacketResponse + (*MsgAcknowledgement)(nil), // 2: tibc.core.packet.v1.MsgAcknowledgement + (*MsgAcknowledgementResponse)(nil), // 3: tibc.core.packet.v1.MsgAcknowledgementResponse + (*MsgCleanPacket)(nil), // 4: tibc.core.packet.v1.MsgCleanPacket + (*MsgCleanPacketResponse)(nil), // 5: tibc.core.packet.v1.MsgCleanPacketResponse + (*MsgRecvCleanPacket)(nil), // 6: tibc.core.packet.v1.MsgRecvCleanPacket + (*MsgRecvCleanPacketResponse)(nil), // 7: tibc.core.packet.v1.MsgRecvCleanPacketResponse + (*Packet)(nil), // 8: tibc.core.packet.v1.Packet + (*v1.Height)(nil), // 9: tibc.core.client.v1.Height + (*CleanPacket)(nil), // 10: tibc.core.packet.v1.CleanPacket +} +var file_tibc_core_packet_v1_tx_proto_depIdxs = []int32{ + 8, // 0: tibc.core.packet.v1.MsgRecvPacket.packet:type_name -> tibc.core.packet.v1.Packet + 9, // 1: tibc.core.packet.v1.MsgRecvPacket.proof_height:type_name -> tibc.core.client.v1.Height + 8, // 2: tibc.core.packet.v1.MsgAcknowledgement.packet:type_name -> tibc.core.packet.v1.Packet + 9, // 3: tibc.core.packet.v1.MsgAcknowledgement.proof_height:type_name -> tibc.core.client.v1.Height + 10, // 4: tibc.core.packet.v1.MsgCleanPacket.clean_packet:type_name -> tibc.core.packet.v1.CleanPacket + 10, // 5: tibc.core.packet.v1.MsgRecvCleanPacket.clean_packet:type_name -> tibc.core.packet.v1.CleanPacket + 9, // 6: tibc.core.packet.v1.MsgRecvCleanPacket.proof_height:type_name -> tibc.core.client.v1.Height + 0, // 7: tibc.core.packet.v1.Msg.RecvPacket:input_type -> tibc.core.packet.v1.MsgRecvPacket + 2, // 8: tibc.core.packet.v1.Msg.Acknowledgement:input_type -> tibc.core.packet.v1.MsgAcknowledgement + 4, // 9: tibc.core.packet.v1.Msg.CleanPacket:input_type -> tibc.core.packet.v1.MsgCleanPacket + 6, // 10: tibc.core.packet.v1.Msg.RecvCleanPacket:input_type -> tibc.core.packet.v1.MsgRecvCleanPacket + 1, // 11: tibc.core.packet.v1.Msg.RecvPacket:output_type -> tibc.core.packet.v1.MsgRecvPacketResponse + 3, // 12: tibc.core.packet.v1.Msg.Acknowledgement:output_type -> tibc.core.packet.v1.MsgAcknowledgementResponse + 5, // 13: tibc.core.packet.v1.Msg.CleanPacket:output_type -> tibc.core.packet.v1.MsgCleanPacketResponse + 7, // 14: tibc.core.packet.v1.Msg.RecvCleanPacket:output_type -> tibc.core.packet.v1.MsgRecvCleanPacketResponse + 11, // [11:15] is the sub-list for method output_type + 7, // [7:11] is the sub-list for method input_type + 7, // [7:7] is the sub-list for extension type_name + 7, // [7:7] is the sub-list for extension extendee + 0, // [0:7] is the sub-list for field type_name +} + +func init() { file_tibc_core_packet_v1_tx_proto_init() } +func file_tibc_core_packet_v1_tx_proto_init() { + if File_tibc_core_packet_v1_tx_proto != nil { + return + } + file_tibc_core_packet_v1_packet_proto_init() + if !protoimpl.UnsafeEnabled { + file_tibc_core_packet_v1_tx_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgRecvPacket); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_tx_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgRecvPacketResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_tx_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgAcknowledgement); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_tx_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgAcknowledgementResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_tx_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgCleanPacket); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_tx_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgCleanPacketResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_tx_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgRecvCleanPacket); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_packet_v1_tx_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgRecvCleanPacketResponse); 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_tibc_core_packet_v1_tx_proto_rawDesc, + NumEnums: 0, + NumMessages: 8, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_tibc_core_packet_v1_tx_proto_goTypes, + DependencyIndexes: file_tibc_core_packet_v1_tx_proto_depIdxs, + MessageInfos: file_tibc_core_packet_v1_tx_proto_msgTypes, + }.Build() + File_tibc_core_packet_v1_tx_proto = out.File + file_tibc_core_packet_v1_tx_proto_rawDesc = nil + file_tibc_core_packet_v1_tx_proto_goTypes = nil + file_tibc_core_packet_v1_tx_proto_depIdxs = nil +} diff --git a/api/tibc/core/packet/v1/tx_grpc.pb.go b/api/tibc/core/packet/v1/tx_grpc.pb.go new file mode 100644 index 00000000..115e3503 --- /dev/null +++ b/api/tibc/core/packet/v1/tx_grpc.pb.go @@ -0,0 +1,228 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: tibc/core/packet/v1/tx.proto + +package packetv1 + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + Msg_RecvPacket_FullMethodName = "/tibc.core.packet.v1.Msg/RecvPacket" + Msg_Acknowledgement_FullMethodName = "/tibc.core.packet.v1.Msg/Acknowledgement" + Msg_CleanPacket_FullMethodName = "/tibc.core.packet.v1.Msg/CleanPacket" + Msg_RecvCleanPacket_FullMethodName = "/tibc.core.packet.v1.Msg/RecvCleanPacket" +) + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type MsgClient interface { + // RecvPacket defines a rpc handler method for MsgRecvPacket. + RecvPacket(ctx context.Context, in *MsgRecvPacket, opts ...grpc.CallOption) (*MsgRecvPacketResponse, error) + // Acknowledgement defines a rpc handler method for MsgAcknowledgement. + Acknowledgement(ctx context.Context, in *MsgAcknowledgement, opts ...grpc.CallOption) (*MsgAcknowledgementResponse, error) + // CleanPacket defines a rpc handler method for MsgCleanPacket. + CleanPacket(ctx context.Context, in *MsgCleanPacket, opts ...grpc.CallOption) (*MsgCleanPacketResponse, error) + // RecvCleanPacket defines a rpc handler method for MsgRecvCleanPacket. + RecvCleanPacket(ctx context.Context, in *MsgRecvCleanPacket, opts ...grpc.CallOption) (*MsgRecvCleanPacketResponse, error) +} + +type msgClient struct { + cc grpc.ClientConnInterface +} + +func NewMsgClient(cc grpc.ClientConnInterface) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) RecvPacket(ctx context.Context, in *MsgRecvPacket, opts ...grpc.CallOption) (*MsgRecvPacketResponse, error) { + out := new(MsgRecvPacketResponse) + err := c.cc.Invoke(ctx, Msg_RecvPacket_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) Acknowledgement(ctx context.Context, in *MsgAcknowledgement, opts ...grpc.CallOption) (*MsgAcknowledgementResponse, error) { + out := new(MsgAcknowledgementResponse) + err := c.cc.Invoke(ctx, Msg_Acknowledgement_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) CleanPacket(ctx context.Context, in *MsgCleanPacket, opts ...grpc.CallOption) (*MsgCleanPacketResponse, error) { + out := new(MsgCleanPacketResponse) + err := c.cc.Invoke(ctx, Msg_CleanPacket_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) RecvCleanPacket(ctx context.Context, in *MsgRecvCleanPacket, opts ...grpc.CallOption) (*MsgRecvCleanPacketResponse, error) { + out := new(MsgRecvCleanPacketResponse) + err := c.cc.Invoke(ctx, Msg_RecvCleanPacket_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +// All implementations must embed UnimplementedMsgServer +// for forward compatibility +type MsgServer interface { + // RecvPacket defines a rpc handler method for MsgRecvPacket. + RecvPacket(context.Context, *MsgRecvPacket) (*MsgRecvPacketResponse, error) + // Acknowledgement defines a rpc handler method for MsgAcknowledgement. + Acknowledgement(context.Context, *MsgAcknowledgement) (*MsgAcknowledgementResponse, error) + // CleanPacket defines a rpc handler method for MsgCleanPacket. + CleanPacket(context.Context, *MsgCleanPacket) (*MsgCleanPacketResponse, error) + // RecvCleanPacket defines a rpc handler method for MsgRecvCleanPacket. + RecvCleanPacket(context.Context, *MsgRecvCleanPacket) (*MsgRecvCleanPacketResponse, error) + mustEmbedUnimplementedMsgServer() +} + +// UnimplementedMsgServer must be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (UnimplementedMsgServer) RecvPacket(context.Context, *MsgRecvPacket) (*MsgRecvPacketResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RecvPacket not implemented") +} +func (UnimplementedMsgServer) Acknowledgement(context.Context, *MsgAcknowledgement) (*MsgAcknowledgementResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Acknowledgement not implemented") +} +func (UnimplementedMsgServer) CleanPacket(context.Context, *MsgCleanPacket) (*MsgCleanPacketResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CleanPacket not implemented") +} +func (UnimplementedMsgServer) RecvCleanPacket(context.Context, *MsgRecvCleanPacket) (*MsgRecvCleanPacketResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RecvCleanPacket not implemented") +} +func (UnimplementedMsgServer) mustEmbedUnimplementedMsgServer() {} + +// UnsafeMsgServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to MsgServer will +// result in compilation errors. +type UnsafeMsgServer interface { + mustEmbedUnimplementedMsgServer() +} + +func RegisterMsgServer(s grpc.ServiceRegistrar, srv MsgServer) { + s.RegisterService(&Msg_ServiceDesc, srv) +} + +func _Msg_RecvPacket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgRecvPacket) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).RecvPacket(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Msg_RecvPacket_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).RecvPacket(ctx, req.(*MsgRecvPacket)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_Acknowledgement_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgAcknowledgement) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).Acknowledgement(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Msg_Acknowledgement_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).Acknowledgement(ctx, req.(*MsgAcknowledgement)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_CleanPacket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgCleanPacket) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).CleanPacket(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Msg_CleanPacket_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).CleanPacket(ctx, req.(*MsgCleanPacket)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_RecvCleanPacket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgRecvCleanPacket) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).RecvCleanPacket(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Msg_RecvCleanPacket_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).RecvCleanPacket(ctx, req.(*MsgRecvCleanPacket)) + } + return interceptor(ctx, in, info, handler) +} + +// Msg_ServiceDesc is the grpc.ServiceDesc for Msg service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Msg_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "tibc.core.packet.v1.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "RecvPacket", + Handler: _Msg_RecvPacket_Handler, + }, + { + MethodName: "Acknowledgement", + Handler: _Msg_Acknowledgement_Handler, + }, + { + MethodName: "CleanPacket", + Handler: _Msg_CleanPacket_Handler, + }, + { + MethodName: "RecvCleanPacket", + Handler: _Msg_RecvCleanPacket_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "tibc/core/packet/v1/tx.proto", +} diff --git a/api/tibc/core/routing/v1/genesis.pulsar.go b/api/tibc/core/routing/v1/genesis.pulsar.go new file mode 100644 index 00000000..e805e50d --- /dev/null +++ b/api/tibc/core/routing/v1/genesis.pulsar.go @@ -0,0 +1,631 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package routingv1 + +import ( + fmt "fmt" + runtime "github.com/cosmos/cosmos-proto/runtime" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoiface "google.golang.org/protobuf/runtime/protoiface" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" + reflect "reflect" + sync "sync" +) + +var _ protoreflect.List = (*_GenesisState_1_list)(nil) + +type _GenesisState_1_list struct { + list *[]string +} + +func (x *_GenesisState_1_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_GenesisState_1_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfString((*x.list)[i]) +} + +func (x *_GenesisState_1_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_GenesisState_1_list) Append(value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_GenesisState_1_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message GenesisState at list field Rules as it is not of Message kind")) +} + +func (x *_GenesisState_1_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_GenesisState_1_list) NewElement() protoreflect.Value { + v := "" + return protoreflect.ValueOfString(v) +} + +func (x *_GenesisState_1_list) IsValid() bool { + return x.list != nil +} + +var ( + md_GenesisState protoreflect.MessageDescriptor + fd_GenesisState_rules protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_routing_v1_genesis_proto_init() + md_GenesisState = File_tibc_core_routing_v1_genesis_proto.Messages().ByName("GenesisState") + fd_GenesisState_rules = md_GenesisState.Fields().ByName("rules") +} + +var _ protoreflect.Message = (*fastReflection_GenesisState)(nil) + +type fastReflection_GenesisState GenesisState + +func (x *GenesisState) ProtoReflect() protoreflect.Message { + return (*fastReflection_GenesisState)(x) +} + +func (x *GenesisState) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_routing_v1_genesis_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_GenesisState_messageType fastReflection_GenesisState_messageType +var _ protoreflect.MessageType = fastReflection_GenesisState_messageType{} + +type fastReflection_GenesisState_messageType struct{} + +func (x fastReflection_GenesisState_messageType) Zero() protoreflect.Message { + return (*fastReflection_GenesisState)(nil) +} +func (x fastReflection_GenesisState_messageType) New() protoreflect.Message { + return new(fastReflection_GenesisState) +} +func (x fastReflection_GenesisState_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_GenesisState +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_GenesisState) Descriptor() protoreflect.MessageDescriptor { + return md_GenesisState +} + +// 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_GenesisState) Type() protoreflect.MessageType { + return _fastReflection_GenesisState_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_GenesisState) New() protoreflect.Message { + return new(fastReflection_GenesisState) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_GenesisState) Interface() protoreflect.ProtoMessage { + return (*GenesisState)(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_GenesisState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.Rules) != 0 { + value := protoreflect.ValueOfList(&_GenesisState_1_list{list: &x.Rules}) + if !f(fd_GenesisState_rules, 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_GenesisState) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.routing.v1.GenesisState.rules": + return len(x.Rules) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.GenesisState 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_GenesisState) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.routing.v1.GenesisState.rules": + x.Rules = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.GenesisState 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_GenesisState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.routing.v1.GenesisState.rules": + if len(x.Rules) == 0 { + return protoreflect.ValueOfList(&_GenesisState_1_list{}) + } + listValue := &_GenesisState_1_list{list: &x.Rules} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.GenesisState 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_GenesisState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.routing.v1.GenesisState.rules": + lv := value.List() + clv := lv.(*_GenesisState_1_list) + x.Rules = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.GenesisState 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_GenesisState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.routing.v1.GenesisState.rules": + if x.Rules == nil { + x.Rules = []string{} + } + value := &_GenesisState_1_list{list: &x.Rules} + return protoreflect.ValueOfList(value) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.GenesisState 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_GenesisState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.routing.v1.GenesisState.rules": + list := []string{} + return protoreflect.ValueOfList(&_GenesisState_1_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.GenesisState 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_GenesisState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.routing.v1.GenesisState", 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_GenesisState) 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_GenesisState) 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_GenesisState) 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_GenesisState) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*GenesisState) + 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.Rules) > 0 { + for _, s := range x.Rules { + l = len(s) + 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().(*GenesisState) + 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.Rules) > 0 { + for iNdEx := len(x.Rules) - 1; iNdEx >= 0; iNdEx-- { + i -= len(x.Rules[iNdEx]) + copy(dAtA[i:], x.Rules[iNdEx]) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Rules[iNdEx]))) + 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().(*GenesisState) + 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: GenesisState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GenesisState: 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 Rules", 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.Rules = append(x.Rules, 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, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: tibc/core/routing/v1/genesis.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) +) + +// GenesisState defines the tibc channel submodule's genesis state. +type GenesisState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Rules []string `protobuf:"bytes,1,rep,name=rules,proto3" json:"rules,omitempty"` +} + +func (x *GenesisState) Reset() { + *x = GenesisState{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_routing_v1_genesis_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GenesisState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GenesisState) ProtoMessage() {} + +// Deprecated: Use GenesisState.ProtoReflect.Descriptor instead. +func (*GenesisState) Descriptor() ([]byte, []int) { + return file_tibc_core_routing_v1_genesis_proto_rawDescGZIP(), []int{0} +} + +func (x *GenesisState) GetRules() []string { + if x != nil { + return x.Rules + } + return nil +} + +var File_tibc_core_routing_v1_genesis_proto protoreflect.FileDescriptor + +var file_tibc_core_routing_v1_genesis_proto_rawDesc = []byte{ + 0x0a, 0x22, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x72, 0x6f, 0x75, 0x74, + 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x14, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x22, 0x24, 0x0a, 0x0c, 0x47, 0x65, + 0x6e, 0x65, 0x73, 0x69, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x72, 0x75, + 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x72, 0x75, 0x6c, 0x65, 0x73, + 0x42, 0xdc, 0x01, 0x0a, 0x18, 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x42, 0x0c, 0x47, + 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3f, 0x67, + 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, + 0x65, 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2d, 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, + 0x67, 0x2f, 0x76, 0x31, 0x3b, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x76, 0x31, 0xa2, 0x02, + 0x03, 0x54, 0x43, 0x52, 0xaa, 0x02, 0x14, 0x54, 0x69, 0x62, 0x63, 0x2e, 0x43, 0x6f, 0x72, 0x65, + 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x14, 0x54, 0x69, + 0x62, 0x63, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5c, + 0x56, 0x31, 0xe2, 0x02, 0x20, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x52, + 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x17, 0x54, 0x69, 0x62, 0x63, 0x3a, 0x3a, 0x43, 0x6f, + 0x72, 0x65, 0x3a, 0x3a, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x3a, 0x3a, 0x56, 0x31, 0x62, + 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_core_routing_v1_genesis_proto_rawDescOnce sync.Once + file_tibc_core_routing_v1_genesis_proto_rawDescData = file_tibc_core_routing_v1_genesis_proto_rawDesc +) + +func file_tibc_core_routing_v1_genesis_proto_rawDescGZIP() []byte { + file_tibc_core_routing_v1_genesis_proto_rawDescOnce.Do(func() { + file_tibc_core_routing_v1_genesis_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_core_routing_v1_genesis_proto_rawDescData) + }) + return file_tibc_core_routing_v1_genesis_proto_rawDescData +} + +var file_tibc_core_routing_v1_genesis_proto_msgTypes = make([]protoimpl.MessageInfo, 1) +var file_tibc_core_routing_v1_genesis_proto_goTypes = []interface{}{ + (*GenesisState)(nil), // 0: tibc.core.routing.v1.GenesisState +} +var file_tibc_core_routing_v1_genesis_proto_depIdxs = []int32{ + 0, // [0:0] is the sub-list for method output_type + 0, // [0:0] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_tibc_core_routing_v1_genesis_proto_init() } +func file_tibc_core_routing_v1_genesis_proto_init() { + if File_tibc_core_routing_v1_genesis_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_tibc_core_routing_v1_genesis_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GenesisState); 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_tibc_core_routing_v1_genesis_proto_rawDesc, + NumEnums: 0, + NumMessages: 1, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_tibc_core_routing_v1_genesis_proto_goTypes, + DependencyIndexes: file_tibc_core_routing_v1_genesis_proto_depIdxs, + MessageInfos: file_tibc_core_routing_v1_genesis_proto_msgTypes, + }.Build() + File_tibc_core_routing_v1_genesis_proto = out.File + file_tibc_core_routing_v1_genesis_proto_rawDesc = nil + file_tibc_core_routing_v1_genesis_proto_goTypes = nil + file_tibc_core_routing_v1_genesis_proto_depIdxs = nil +} diff --git a/api/tibc/core/routing/v1/query.pulsar.go b/api/tibc/core/routing/v1/query.pulsar.go new file mode 100644 index 00000000..76beec0a --- /dev/null +++ b/api/tibc/core/routing/v1/query.pulsar.go @@ -0,0 +1,1047 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package routingv1 + +import ( + fmt "fmt" + runtime "github.com/cosmos/cosmos-proto/runtime" + _ "google.golang.org/genproto/googleapis/api/annotations" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoiface "google.golang.org/protobuf/runtime/protoiface" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_QueryRoutingRulesRequest protoreflect.MessageDescriptor +) + +func init() { + file_tibc_core_routing_v1_query_proto_init() + md_QueryRoutingRulesRequest = File_tibc_core_routing_v1_query_proto.Messages().ByName("QueryRoutingRulesRequest") +} + +var _ protoreflect.Message = (*fastReflection_QueryRoutingRulesRequest)(nil) + +type fastReflection_QueryRoutingRulesRequest QueryRoutingRulesRequest + +func (x *QueryRoutingRulesRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryRoutingRulesRequest)(x) +} + +func (x *QueryRoutingRulesRequest) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_routing_v1_query_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryRoutingRulesRequest_messageType fastReflection_QueryRoutingRulesRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryRoutingRulesRequest_messageType{} + +type fastReflection_QueryRoutingRulesRequest_messageType struct{} + +func (x fastReflection_QueryRoutingRulesRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryRoutingRulesRequest)(nil) +} +func (x fastReflection_QueryRoutingRulesRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryRoutingRulesRequest) +} +func (x fastReflection_QueryRoutingRulesRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryRoutingRulesRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryRoutingRulesRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryRoutingRulesRequest +} + +// 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_QueryRoutingRulesRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryRoutingRulesRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryRoutingRulesRequest) New() protoreflect.Message { + return new(fastReflection_QueryRoutingRulesRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryRoutingRulesRequest) Interface() protoreflect.ProtoMessage { + return (*QueryRoutingRulesRequest)(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_QueryRoutingRulesRequest) 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_QueryRoutingRulesRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.QueryRoutingRulesRequest")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.QueryRoutingRulesRequest 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_QueryRoutingRulesRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.QueryRoutingRulesRequest")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.QueryRoutingRulesRequest 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_QueryRoutingRulesRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.QueryRoutingRulesRequest")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.QueryRoutingRulesRequest 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_QueryRoutingRulesRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.QueryRoutingRulesRequest")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.QueryRoutingRulesRequest 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_QueryRoutingRulesRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.QueryRoutingRulesRequest")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.QueryRoutingRulesRequest 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_QueryRoutingRulesRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.QueryRoutingRulesRequest")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.QueryRoutingRulesRequest 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_QueryRoutingRulesRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.routing.v1.QueryRoutingRulesRequest", 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_QueryRoutingRulesRequest) 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_QueryRoutingRulesRequest) 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_QueryRoutingRulesRequest) 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_QueryRoutingRulesRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryRoutingRulesRequest) + 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().(*QueryRoutingRulesRequest) + 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().(*QueryRoutingRulesRequest) + 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: QueryRoutingRulesRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryRoutingRulesRequest: 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 = (*_QueryRoutingRulesResponse_1_list)(nil) + +type _QueryRoutingRulesResponse_1_list struct { + list *[]string +} + +func (x *_QueryRoutingRulesResponse_1_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_QueryRoutingRulesResponse_1_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfString((*x.list)[i]) +} + +func (x *_QueryRoutingRulesResponse_1_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_QueryRoutingRulesResponse_1_list) Append(value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_QueryRoutingRulesResponse_1_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message QueryRoutingRulesResponse at list field Rules as it is not of Message kind")) +} + +func (x *_QueryRoutingRulesResponse_1_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_QueryRoutingRulesResponse_1_list) NewElement() protoreflect.Value { + v := "" + return protoreflect.ValueOfString(v) +} + +func (x *_QueryRoutingRulesResponse_1_list) IsValid() bool { + return x.list != nil +} + +var ( + md_QueryRoutingRulesResponse protoreflect.MessageDescriptor + fd_QueryRoutingRulesResponse_rules protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_routing_v1_query_proto_init() + md_QueryRoutingRulesResponse = File_tibc_core_routing_v1_query_proto.Messages().ByName("QueryRoutingRulesResponse") + fd_QueryRoutingRulesResponse_rules = md_QueryRoutingRulesResponse.Fields().ByName("rules") +} + +var _ protoreflect.Message = (*fastReflection_QueryRoutingRulesResponse)(nil) + +type fastReflection_QueryRoutingRulesResponse QueryRoutingRulesResponse + +func (x *QueryRoutingRulesResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryRoutingRulesResponse)(x) +} + +func (x *QueryRoutingRulesResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_routing_v1_query_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryRoutingRulesResponse_messageType fastReflection_QueryRoutingRulesResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryRoutingRulesResponse_messageType{} + +type fastReflection_QueryRoutingRulesResponse_messageType struct{} + +func (x fastReflection_QueryRoutingRulesResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryRoutingRulesResponse)(nil) +} +func (x fastReflection_QueryRoutingRulesResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryRoutingRulesResponse) +} +func (x fastReflection_QueryRoutingRulesResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryRoutingRulesResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryRoutingRulesResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryRoutingRulesResponse +} + +// 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_QueryRoutingRulesResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryRoutingRulesResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryRoutingRulesResponse) New() protoreflect.Message { + return new(fastReflection_QueryRoutingRulesResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryRoutingRulesResponse) Interface() protoreflect.ProtoMessage { + return (*QueryRoutingRulesResponse)(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_QueryRoutingRulesResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.Rules) != 0 { + value := protoreflect.ValueOfList(&_QueryRoutingRulesResponse_1_list{list: &x.Rules}) + if !f(fd_QueryRoutingRulesResponse_rules, 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_QueryRoutingRulesResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.routing.v1.QueryRoutingRulesResponse.rules": + return len(x.Rules) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.QueryRoutingRulesResponse")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.QueryRoutingRulesResponse 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_QueryRoutingRulesResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.routing.v1.QueryRoutingRulesResponse.rules": + x.Rules = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.QueryRoutingRulesResponse")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.QueryRoutingRulesResponse 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_QueryRoutingRulesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.routing.v1.QueryRoutingRulesResponse.rules": + if len(x.Rules) == 0 { + return protoreflect.ValueOfList(&_QueryRoutingRulesResponse_1_list{}) + } + listValue := &_QueryRoutingRulesResponse_1_list{list: &x.Rules} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.QueryRoutingRulesResponse")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.QueryRoutingRulesResponse 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_QueryRoutingRulesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.routing.v1.QueryRoutingRulesResponse.rules": + lv := value.List() + clv := lv.(*_QueryRoutingRulesResponse_1_list) + x.Rules = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.QueryRoutingRulesResponse")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.QueryRoutingRulesResponse 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_QueryRoutingRulesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.routing.v1.QueryRoutingRulesResponse.rules": + if x.Rules == nil { + x.Rules = []string{} + } + value := &_QueryRoutingRulesResponse_1_list{list: &x.Rules} + return protoreflect.ValueOfList(value) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.QueryRoutingRulesResponse")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.QueryRoutingRulesResponse 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_QueryRoutingRulesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.routing.v1.QueryRoutingRulesResponse.rules": + list := []string{} + return protoreflect.ValueOfList(&_QueryRoutingRulesResponse_1_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.QueryRoutingRulesResponse")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.QueryRoutingRulesResponse 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_QueryRoutingRulesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.routing.v1.QueryRoutingRulesResponse", 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_QueryRoutingRulesResponse) 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_QueryRoutingRulesResponse) 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_QueryRoutingRulesResponse) 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_QueryRoutingRulesResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryRoutingRulesResponse) + 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.Rules) > 0 { + for _, s := range x.Rules { + l = len(s) + 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().(*QueryRoutingRulesResponse) + 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.Rules) > 0 { + for iNdEx := len(x.Rules) - 1; iNdEx >= 0; iNdEx-- { + i -= len(x.Rules[iNdEx]) + copy(dAtA[i:], x.Rules[iNdEx]) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Rules[iNdEx]))) + 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().(*QueryRoutingRulesResponse) + 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: QueryRoutingRulesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryRoutingRulesResponse: 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 Rules", 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.Rules = append(x.Rules, 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, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: tibc/core/routing/v1/query.proto + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// QueryRoutingRulesRequest is the request type for the +// RoutingRules RPC method +type QueryRoutingRulesRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *QueryRoutingRulesRequest) Reset() { + *x = QueryRoutingRulesRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_routing_v1_query_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryRoutingRulesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryRoutingRulesRequest) ProtoMessage() {} + +// Deprecated: Use QueryRoutingRulesRequest.ProtoReflect.Descriptor instead. +func (*QueryRoutingRulesRequest) Descriptor() ([]byte, []int) { + return file_tibc_core_routing_v1_query_proto_rawDescGZIP(), []int{0} +} + +// QueryRoutingRulesResponse defines the routing rules query response +type QueryRoutingRulesResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // rule string array + Rules []string `protobuf:"bytes,1,rep,name=rules,proto3" json:"rules,omitempty"` +} + +func (x *QueryRoutingRulesResponse) Reset() { + *x = QueryRoutingRulesResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_routing_v1_query_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryRoutingRulesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryRoutingRulesResponse) ProtoMessage() {} + +// Deprecated: Use QueryRoutingRulesResponse.ProtoReflect.Descriptor instead. +func (*QueryRoutingRulesResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_routing_v1_query_proto_rawDescGZIP(), []int{1} +} + +func (x *QueryRoutingRulesResponse) GetRules() []string { + if x != nil { + return x.Rules + } + return nil +} + +var File_tibc_core_routing_v1_query_proto protoreflect.FileDescriptor + +var file_tibc_core_routing_v1_query_proto_rawDesc = []byte{ + 0x0a, 0x20, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x72, 0x6f, 0x75, 0x74, + 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x12, 0x14, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x72, 0x6f, + 0x75, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x1a, 0x0a, 0x18, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, + 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x22, 0x31, 0x0a, 0x19, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x6f, 0x75, 0x74, 0x69, + 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x14, 0x0a, 0x05, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, + 0x72, 0x75, 0x6c, 0x65, 0x73, 0x32, 0xab, 0x01, 0x0a, 0x05, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, + 0xa1, 0x01, 0x0a, 0x0c, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, + 0x12, 0x2e, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x72, 0x6f, 0x75, + 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x6f, 0x75, + 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x2f, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x72, 0x6f, 0x75, + 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x6f, 0x75, + 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x30, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2a, 0x12, 0x28, 0x2f, 0x74, 0x69, 0x62, 0x63, + 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, + 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x75, + 0x6c, 0x65, 0x73, 0x42, 0xda, 0x01, 0x0a, 0x18, 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, 0x63, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, + 0x42, 0x0a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3f, + 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, + 0x69, 0x65, 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2d, 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, + 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x72, 0x6f, 0x75, 0x74, 0x69, + 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x3b, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x76, 0x31, 0xa2, + 0x02, 0x03, 0x54, 0x43, 0x52, 0xaa, 0x02, 0x14, 0x54, 0x69, 0x62, 0x63, 0x2e, 0x43, 0x6f, 0x72, + 0x65, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x14, 0x54, + 0x69, 0x62, 0x63, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, + 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x20, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, + 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x17, 0x54, 0x69, 0x62, 0x63, 0x3a, 0x3a, 0x43, + 0x6f, 0x72, 0x65, 0x3a, 0x3a, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x3a, 0x3a, 0x56, 0x31, + 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_core_routing_v1_query_proto_rawDescOnce sync.Once + file_tibc_core_routing_v1_query_proto_rawDescData = file_tibc_core_routing_v1_query_proto_rawDesc +) + +func file_tibc_core_routing_v1_query_proto_rawDescGZIP() []byte { + file_tibc_core_routing_v1_query_proto_rawDescOnce.Do(func() { + file_tibc_core_routing_v1_query_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_core_routing_v1_query_proto_rawDescData) + }) + return file_tibc_core_routing_v1_query_proto_rawDescData +} + +var file_tibc_core_routing_v1_query_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_tibc_core_routing_v1_query_proto_goTypes = []interface{}{ + (*QueryRoutingRulesRequest)(nil), // 0: tibc.core.routing.v1.QueryRoutingRulesRequest + (*QueryRoutingRulesResponse)(nil), // 1: tibc.core.routing.v1.QueryRoutingRulesResponse +} +var file_tibc_core_routing_v1_query_proto_depIdxs = []int32{ + 0, // 0: tibc.core.routing.v1.Query.RoutingRules:input_type -> tibc.core.routing.v1.QueryRoutingRulesRequest + 1, // 1: tibc.core.routing.v1.Query.RoutingRules:output_type -> tibc.core.routing.v1.QueryRoutingRulesResponse + 1, // [1:2] is the sub-list for method output_type + 0, // [0:1] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_tibc_core_routing_v1_query_proto_init() } +func file_tibc_core_routing_v1_query_proto_init() { + if File_tibc_core_routing_v1_query_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_tibc_core_routing_v1_query_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryRoutingRulesRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_routing_v1_query_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryRoutingRulesResponse); 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_tibc_core_routing_v1_query_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_tibc_core_routing_v1_query_proto_goTypes, + DependencyIndexes: file_tibc_core_routing_v1_query_proto_depIdxs, + MessageInfos: file_tibc_core_routing_v1_query_proto_msgTypes, + }.Build() + File_tibc_core_routing_v1_query_proto = out.File + file_tibc_core_routing_v1_query_proto_rawDesc = nil + file_tibc_core_routing_v1_query_proto_goTypes = nil + file_tibc_core_routing_v1_query_proto_depIdxs = nil +} diff --git a/api/tibc/core/routing/v1/query_grpc.pb.go b/api/tibc/core/routing/v1/query_grpc.pb.go new file mode 100644 index 00000000..93cadb03 --- /dev/null +++ b/api/tibc/core/routing/v1/query_grpc.pb.go @@ -0,0 +1,111 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: tibc/core/routing/v1/query.proto + +package routingv1 + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + Query_RoutingRules_FullMethodName = "/tibc.core.routing.v1.Query/RoutingRules" +) + +// QueryClient is the client API for Query service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type QueryClient interface { + // RoutingRules queries all routing rules. + RoutingRules(ctx context.Context, in *QueryRoutingRulesRequest, opts ...grpc.CallOption) (*QueryRoutingRulesResponse, error) +} + +type queryClient struct { + cc grpc.ClientConnInterface +} + +func NewQueryClient(cc grpc.ClientConnInterface) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) RoutingRules(ctx context.Context, in *QueryRoutingRulesRequest, opts ...grpc.CallOption) (*QueryRoutingRulesResponse, error) { + out := new(QueryRoutingRulesResponse) + err := c.cc.Invoke(ctx, Query_RoutingRules_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +// All implementations must embed UnimplementedQueryServer +// for forward compatibility +type QueryServer interface { + // RoutingRules queries all routing rules. + RoutingRules(context.Context, *QueryRoutingRulesRequest) (*QueryRoutingRulesResponse, error) + mustEmbedUnimplementedQueryServer() +} + +// UnimplementedQueryServer must be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct { +} + +func (UnimplementedQueryServer) RoutingRules(context.Context, *QueryRoutingRulesRequest) (*QueryRoutingRulesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RoutingRules not implemented") +} +func (UnimplementedQueryServer) mustEmbedUnimplementedQueryServer() {} + +// UnsafeQueryServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to QueryServer will +// result in compilation errors. +type UnsafeQueryServer interface { + mustEmbedUnimplementedQueryServer() +} + +func RegisterQueryServer(s grpc.ServiceRegistrar, srv QueryServer) { + s.RegisterService(&Query_ServiceDesc, srv) +} + +func _Query_RoutingRules_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryRoutingRulesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).RoutingRules(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_RoutingRules_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).RoutingRules(ctx, req.(*QueryRoutingRulesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// Query_ServiceDesc is the grpc.ServiceDesc for Query service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Query_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "tibc.core.routing.v1.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "RoutingRules", + Handler: _Query_RoutingRules_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "tibc/core/routing/v1/query.proto", +} diff --git a/api/tibc/core/routing/v1/routing.pulsar.go b/api/tibc/core/routing/v1/routing.pulsar.go new file mode 100644 index 00000000..d73ea30f --- /dev/null +++ b/api/tibc/core/routing/v1/routing.pulsar.go @@ -0,0 +1,785 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package routingv1 + +import ( + fmt "fmt" + 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" + io "io" + reflect "reflect" + sync "sync" +) + +var _ protoreflect.List = (*_SetRoutingRulesProposal_3_list)(nil) + +type _SetRoutingRulesProposal_3_list struct { + list *[]string +} + +func (x *_SetRoutingRulesProposal_3_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_SetRoutingRulesProposal_3_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfString((*x.list)[i]) +} + +func (x *_SetRoutingRulesProposal_3_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_SetRoutingRulesProposal_3_list) Append(value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_SetRoutingRulesProposal_3_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message SetRoutingRulesProposal at list field Rules as it is not of Message kind")) +} + +func (x *_SetRoutingRulesProposal_3_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_SetRoutingRulesProposal_3_list) NewElement() protoreflect.Value { + v := "" + return protoreflect.ValueOfString(v) +} + +func (x *_SetRoutingRulesProposal_3_list) IsValid() bool { + return x.list != nil +} + +var ( + md_SetRoutingRulesProposal protoreflect.MessageDescriptor + fd_SetRoutingRulesProposal_title protoreflect.FieldDescriptor + fd_SetRoutingRulesProposal_description protoreflect.FieldDescriptor + fd_SetRoutingRulesProposal_rules protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_routing_v1_routing_proto_init() + md_SetRoutingRulesProposal = File_tibc_core_routing_v1_routing_proto.Messages().ByName("SetRoutingRulesProposal") + fd_SetRoutingRulesProposal_title = md_SetRoutingRulesProposal.Fields().ByName("title") + fd_SetRoutingRulesProposal_description = md_SetRoutingRulesProposal.Fields().ByName("description") + fd_SetRoutingRulesProposal_rules = md_SetRoutingRulesProposal.Fields().ByName("rules") +} + +var _ protoreflect.Message = (*fastReflection_SetRoutingRulesProposal)(nil) + +type fastReflection_SetRoutingRulesProposal SetRoutingRulesProposal + +func (x *SetRoutingRulesProposal) ProtoReflect() protoreflect.Message { + return (*fastReflection_SetRoutingRulesProposal)(x) +} + +func (x *SetRoutingRulesProposal) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_routing_v1_routing_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_SetRoutingRulesProposal_messageType fastReflection_SetRoutingRulesProposal_messageType +var _ protoreflect.MessageType = fastReflection_SetRoutingRulesProposal_messageType{} + +type fastReflection_SetRoutingRulesProposal_messageType struct{} + +func (x fastReflection_SetRoutingRulesProposal_messageType) Zero() protoreflect.Message { + return (*fastReflection_SetRoutingRulesProposal)(nil) +} +func (x fastReflection_SetRoutingRulesProposal_messageType) New() protoreflect.Message { + return new(fastReflection_SetRoutingRulesProposal) +} +func (x fastReflection_SetRoutingRulesProposal_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_SetRoutingRulesProposal +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_SetRoutingRulesProposal) Descriptor() protoreflect.MessageDescriptor { + return md_SetRoutingRulesProposal +} + +// 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_SetRoutingRulesProposal) Type() protoreflect.MessageType { + return _fastReflection_SetRoutingRulesProposal_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_SetRoutingRulesProposal) New() protoreflect.Message { + return new(fastReflection_SetRoutingRulesProposal) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_SetRoutingRulesProposal) Interface() protoreflect.ProtoMessage { + return (*SetRoutingRulesProposal)(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_SetRoutingRulesProposal) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Title != "" { + value := protoreflect.ValueOfString(x.Title) + if !f(fd_SetRoutingRulesProposal_title, value) { + return + } + } + if x.Description != "" { + value := protoreflect.ValueOfString(x.Description) + if !f(fd_SetRoutingRulesProposal_description, value) { + return + } + } + if len(x.Rules) != 0 { + value := protoreflect.ValueOfList(&_SetRoutingRulesProposal_3_list{list: &x.Rules}) + if !f(fd_SetRoutingRulesProposal_rules, 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_SetRoutingRulesProposal) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.routing.v1.SetRoutingRulesProposal.title": + return x.Title != "" + case "tibc.core.routing.v1.SetRoutingRulesProposal.description": + return x.Description != "" + case "tibc.core.routing.v1.SetRoutingRulesProposal.rules": + return len(x.Rules) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.SetRoutingRulesProposal")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.SetRoutingRulesProposal 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_SetRoutingRulesProposal) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.routing.v1.SetRoutingRulesProposal.title": + x.Title = "" + case "tibc.core.routing.v1.SetRoutingRulesProposal.description": + x.Description = "" + case "tibc.core.routing.v1.SetRoutingRulesProposal.rules": + x.Rules = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.SetRoutingRulesProposal")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.SetRoutingRulesProposal 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_SetRoutingRulesProposal) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.routing.v1.SetRoutingRulesProposal.title": + value := x.Title + return protoreflect.ValueOfString(value) + case "tibc.core.routing.v1.SetRoutingRulesProposal.description": + value := x.Description + return protoreflect.ValueOfString(value) + case "tibc.core.routing.v1.SetRoutingRulesProposal.rules": + if len(x.Rules) == 0 { + return protoreflect.ValueOfList(&_SetRoutingRulesProposal_3_list{}) + } + listValue := &_SetRoutingRulesProposal_3_list{list: &x.Rules} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.SetRoutingRulesProposal")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.SetRoutingRulesProposal 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_SetRoutingRulesProposal) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.routing.v1.SetRoutingRulesProposal.title": + x.Title = value.Interface().(string) + case "tibc.core.routing.v1.SetRoutingRulesProposal.description": + x.Description = value.Interface().(string) + case "tibc.core.routing.v1.SetRoutingRulesProposal.rules": + lv := value.List() + clv := lv.(*_SetRoutingRulesProposal_3_list) + x.Rules = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.SetRoutingRulesProposal")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.SetRoutingRulesProposal 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_SetRoutingRulesProposal) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.routing.v1.SetRoutingRulesProposal.rules": + if x.Rules == nil { + x.Rules = []string{} + } + value := &_SetRoutingRulesProposal_3_list{list: &x.Rules} + return protoreflect.ValueOfList(value) + case "tibc.core.routing.v1.SetRoutingRulesProposal.title": + panic(fmt.Errorf("field title of message tibc.core.routing.v1.SetRoutingRulesProposal is not mutable")) + case "tibc.core.routing.v1.SetRoutingRulesProposal.description": + panic(fmt.Errorf("field description of message tibc.core.routing.v1.SetRoutingRulesProposal is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.SetRoutingRulesProposal")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.SetRoutingRulesProposal 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_SetRoutingRulesProposal) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.routing.v1.SetRoutingRulesProposal.title": + return protoreflect.ValueOfString("") + case "tibc.core.routing.v1.SetRoutingRulesProposal.description": + return protoreflect.ValueOfString("") + case "tibc.core.routing.v1.SetRoutingRulesProposal.rules": + list := []string{} + return protoreflect.ValueOfList(&_SetRoutingRulesProposal_3_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.SetRoutingRulesProposal")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.SetRoutingRulesProposal 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_SetRoutingRulesProposal) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.routing.v1.SetRoutingRulesProposal", 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_SetRoutingRulesProposal) 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_SetRoutingRulesProposal) 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_SetRoutingRulesProposal) 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_SetRoutingRulesProposal) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*SetRoutingRulesProposal) + 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.Title) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Description) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.Rules) > 0 { + for _, s := range x.Rules { + l = len(s) + 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().(*SetRoutingRulesProposal) + 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.Rules) > 0 { + for iNdEx := len(x.Rules) - 1; iNdEx >= 0; iNdEx-- { + i -= len(x.Rules[iNdEx]) + copy(dAtA[i:], x.Rules[iNdEx]) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Rules[iNdEx]))) + i-- + dAtA[i] = 0x1a + } + } + if len(x.Description) > 0 { + i -= len(x.Description) + copy(dAtA[i:], x.Description) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Description))) + i-- + dAtA[i] = 0x12 + } + if len(x.Title) > 0 { + i -= len(x.Title) + copy(dAtA[i:], x.Title) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Title))) + 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().(*SetRoutingRulesProposal) + 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: SetRoutingRulesProposal: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: SetRoutingRulesProposal: 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 Title", 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.Title = 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 Description", 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.Description = 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 Rules", 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.Rules = append(x.Rules, 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, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: tibc/core/routing/v1/routing.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) +) + +// SetRoutingRulesProposal defines a proposal to set routing rules +type SetRoutingRulesProposal struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // the title of the update proposal + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` + // the description of the proposal + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` + // routing rules list + Rules []string `protobuf:"bytes,3,rep,name=rules,proto3" json:"rules,omitempty"` +} + +func (x *SetRoutingRulesProposal) Reset() { + *x = SetRoutingRulesProposal{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_routing_v1_routing_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SetRoutingRulesProposal) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetRoutingRulesProposal) ProtoMessage() {} + +// Deprecated: Use SetRoutingRulesProposal.ProtoReflect.Descriptor instead. +func (*SetRoutingRulesProposal) Descriptor() ([]byte, []int) { + return file_tibc_core_routing_v1_routing_proto_rawDescGZIP(), []int{0} +} + +func (x *SetRoutingRulesProposal) GetTitle() string { + if x != nil { + return x.Title + } + return "" +} + +func (x *SetRoutingRulesProposal) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +func (x *SetRoutingRulesProposal) GetRules() []string { + if x != nil { + return x.Rules + } + return nil +} + +var File_tibc_core_routing_v1_routing_proto protoreflect.FileDescriptor + +var file_tibc_core_routing_v1_routing_proto_rawDesc = []byte{ + 0x0a, 0x22, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x72, 0x6f, 0x75, 0x74, + 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x14, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x22, 0x6d, 0x0a, 0x17, 0x53, 0x65, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, + 0x6c, 0x65, 0x73, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x74, + 0x69, 0x74, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x69, 0x74, 0x6c, + 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, + 0x28, 0x09, 0x52, 0x05, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x3a, 0x04, 0x88, 0xa0, 0x1f, 0x00, 0x42, + 0xdc, 0x01, 0x0a, 0x18, 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, + 0x65, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x42, 0x0c, 0x52, 0x6f, + 0x75, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3f, 0x67, 0x69, + 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, 0x65, + 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2d, 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x74, + 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, + 0x2f, 0x76, 0x31, 0x3b, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x76, 0x31, 0xa2, 0x02, 0x03, + 0x54, 0x43, 0x52, 0xaa, 0x02, 0x14, 0x54, 0x69, 0x62, 0x63, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0x2e, + 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x14, 0x54, 0x69, 0x62, + 0x63, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5c, 0x56, + 0x31, 0xe2, 0x02, 0x20, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x52, 0x6f, + 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x17, 0x54, 0x69, 0x62, 0x63, 0x3a, 0x3a, 0x43, 0x6f, 0x72, + 0x65, 0x3a, 0x3a, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_core_routing_v1_routing_proto_rawDescOnce sync.Once + file_tibc_core_routing_v1_routing_proto_rawDescData = file_tibc_core_routing_v1_routing_proto_rawDesc +) + +func file_tibc_core_routing_v1_routing_proto_rawDescGZIP() []byte { + file_tibc_core_routing_v1_routing_proto_rawDescOnce.Do(func() { + file_tibc_core_routing_v1_routing_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_core_routing_v1_routing_proto_rawDescData) + }) + return file_tibc_core_routing_v1_routing_proto_rawDescData +} + +var file_tibc_core_routing_v1_routing_proto_msgTypes = make([]protoimpl.MessageInfo, 1) +var file_tibc_core_routing_v1_routing_proto_goTypes = []interface{}{ + (*SetRoutingRulesProposal)(nil), // 0: tibc.core.routing.v1.SetRoutingRulesProposal +} +var file_tibc_core_routing_v1_routing_proto_depIdxs = []int32{ + 0, // [0:0] is the sub-list for method output_type + 0, // [0:0] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_tibc_core_routing_v1_routing_proto_init() } +func file_tibc_core_routing_v1_routing_proto_init() { + if File_tibc_core_routing_v1_routing_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_tibc_core_routing_v1_routing_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SetRoutingRulesProposal); 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_tibc_core_routing_v1_routing_proto_rawDesc, + NumEnums: 0, + NumMessages: 1, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_tibc_core_routing_v1_routing_proto_goTypes, + DependencyIndexes: file_tibc_core_routing_v1_routing_proto_depIdxs, + MessageInfos: file_tibc_core_routing_v1_routing_proto_msgTypes, + }.Build() + File_tibc_core_routing_v1_routing_proto = out.File + file_tibc_core_routing_v1_routing_proto_rawDesc = nil + file_tibc_core_routing_v1_routing_proto_goTypes = nil + file_tibc_core_routing_v1_routing_proto_depIdxs = nil +} diff --git a/api/tibc/core/routing/v1/tx.pulsar.go b/api/tibc/core/routing/v1/tx.pulsar.go new file mode 100644 index 00000000..d5856978 --- /dev/null +++ b/api/tibc/core/routing/v1/tx.pulsar.go @@ -0,0 +1,1277 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package routingv1 + +import ( + _ "cosmossdk.io/api/cosmos/msg/v1" + 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" + _ "google.golang.org/protobuf/types/known/anypb" + io "io" + reflect "reflect" + sync "sync" +) + +var _ protoreflect.List = (*_MsgSetRoutingRules_3_list)(nil) + +type _MsgSetRoutingRules_3_list struct { + list *[]string +} + +func (x *_MsgSetRoutingRules_3_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_MsgSetRoutingRules_3_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfString((*x.list)[i]) +} + +func (x *_MsgSetRoutingRules_3_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_MsgSetRoutingRules_3_list) Append(value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_MsgSetRoutingRules_3_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message MsgSetRoutingRules at list field Rules as it is not of Message kind")) +} + +func (x *_MsgSetRoutingRules_3_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_MsgSetRoutingRules_3_list) NewElement() protoreflect.Value { + v := "" + return protoreflect.ValueOfString(v) +} + +func (x *_MsgSetRoutingRules_3_list) IsValid() bool { + return x.list != nil +} + +var ( + md_MsgSetRoutingRules protoreflect.MessageDescriptor + fd_MsgSetRoutingRules_title protoreflect.FieldDescriptor + fd_MsgSetRoutingRules_description protoreflect.FieldDescriptor + fd_MsgSetRoutingRules_rules protoreflect.FieldDescriptor + fd_MsgSetRoutingRules_authority protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_routing_v1_tx_proto_init() + md_MsgSetRoutingRules = File_tibc_core_routing_v1_tx_proto.Messages().ByName("MsgSetRoutingRules") + fd_MsgSetRoutingRules_title = md_MsgSetRoutingRules.Fields().ByName("title") + fd_MsgSetRoutingRules_description = md_MsgSetRoutingRules.Fields().ByName("description") + fd_MsgSetRoutingRules_rules = md_MsgSetRoutingRules.Fields().ByName("rules") + fd_MsgSetRoutingRules_authority = md_MsgSetRoutingRules.Fields().ByName("authority") +} + +var _ protoreflect.Message = (*fastReflection_MsgSetRoutingRules)(nil) + +type fastReflection_MsgSetRoutingRules MsgSetRoutingRules + +func (x *MsgSetRoutingRules) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgSetRoutingRules)(x) +} + +func (x *MsgSetRoutingRules) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_routing_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_MsgSetRoutingRules_messageType fastReflection_MsgSetRoutingRules_messageType +var _ protoreflect.MessageType = fastReflection_MsgSetRoutingRules_messageType{} + +type fastReflection_MsgSetRoutingRules_messageType struct{} + +func (x fastReflection_MsgSetRoutingRules_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgSetRoutingRules)(nil) +} +func (x fastReflection_MsgSetRoutingRules_messageType) New() protoreflect.Message { + return new(fastReflection_MsgSetRoutingRules) +} +func (x fastReflection_MsgSetRoutingRules_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgSetRoutingRules +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgSetRoutingRules) Descriptor() protoreflect.MessageDescriptor { + return md_MsgSetRoutingRules +} + +// 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_MsgSetRoutingRules) Type() protoreflect.MessageType { + return _fastReflection_MsgSetRoutingRules_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgSetRoutingRules) New() protoreflect.Message { + return new(fastReflection_MsgSetRoutingRules) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgSetRoutingRules) Interface() protoreflect.ProtoMessage { + return (*MsgSetRoutingRules)(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_MsgSetRoutingRules) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Title != "" { + value := protoreflect.ValueOfString(x.Title) + if !f(fd_MsgSetRoutingRules_title, value) { + return + } + } + if x.Description != "" { + value := protoreflect.ValueOfString(x.Description) + if !f(fd_MsgSetRoutingRules_description, value) { + return + } + } + if len(x.Rules) != 0 { + value := protoreflect.ValueOfList(&_MsgSetRoutingRules_3_list{list: &x.Rules}) + if !f(fd_MsgSetRoutingRules_rules, value) { + return + } + } + if x.Authority != "" { + value := protoreflect.ValueOfString(x.Authority) + if !f(fd_MsgSetRoutingRules_authority, 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_MsgSetRoutingRules) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.routing.v1.MsgSetRoutingRules.title": + return x.Title != "" + case "tibc.core.routing.v1.MsgSetRoutingRules.description": + return x.Description != "" + case "tibc.core.routing.v1.MsgSetRoutingRules.rules": + return len(x.Rules) != 0 + case "tibc.core.routing.v1.MsgSetRoutingRules.authority": + return x.Authority != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.MsgSetRoutingRules")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.MsgSetRoutingRules 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_MsgSetRoutingRules) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.routing.v1.MsgSetRoutingRules.title": + x.Title = "" + case "tibc.core.routing.v1.MsgSetRoutingRules.description": + x.Description = "" + case "tibc.core.routing.v1.MsgSetRoutingRules.rules": + x.Rules = nil + case "tibc.core.routing.v1.MsgSetRoutingRules.authority": + x.Authority = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.MsgSetRoutingRules")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.MsgSetRoutingRules 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_MsgSetRoutingRules) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.routing.v1.MsgSetRoutingRules.title": + value := x.Title + return protoreflect.ValueOfString(value) + case "tibc.core.routing.v1.MsgSetRoutingRules.description": + value := x.Description + return protoreflect.ValueOfString(value) + case "tibc.core.routing.v1.MsgSetRoutingRules.rules": + if len(x.Rules) == 0 { + return protoreflect.ValueOfList(&_MsgSetRoutingRules_3_list{}) + } + listValue := &_MsgSetRoutingRules_3_list{list: &x.Rules} + return protoreflect.ValueOfList(listValue) + case "tibc.core.routing.v1.MsgSetRoutingRules.authority": + value := x.Authority + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.MsgSetRoutingRules")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.MsgSetRoutingRules 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_MsgSetRoutingRules) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.routing.v1.MsgSetRoutingRules.title": + x.Title = value.Interface().(string) + case "tibc.core.routing.v1.MsgSetRoutingRules.description": + x.Description = value.Interface().(string) + case "tibc.core.routing.v1.MsgSetRoutingRules.rules": + lv := value.List() + clv := lv.(*_MsgSetRoutingRules_3_list) + x.Rules = *clv.list + case "tibc.core.routing.v1.MsgSetRoutingRules.authority": + x.Authority = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.MsgSetRoutingRules")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.MsgSetRoutingRules 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_MsgSetRoutingRules) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.routing.v1.MsgSetRoutingRules.rules": + if x.Rules == nil { + x.Rules = []string{} + } + value := &_MsgSetRoutingRules_3_list{list: &x.Rules} + return protoreflect.ValueOfList(value) + case "tibc.core.routing.v1.MsgSetRoutingRules.title": + panic(fmt.Errorf("field title of message tibc.core.routing.v1.MsgSetRoutingRules is not mutable")) + case "tibc.core.routing.v1.MsgSetRoutingRules.description": + panic(fmt.Errorf("field description of message tibc.core.routing.v1.MsgSetRoutingRules is not mutable")) + case "tibc.core.routing.v1.MsgSetRoutingRules.authority": + panic(fmt.Errorf("field authority of message tibc.core.routing.v1.MsgSetRoutingRules is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.MsgSetRoutingRules")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.MsgSetRoutingRules 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_MsgSetRoutingRules) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.routing.v1.MsgSetRoutingRules.title": + return protoreflect.ValueOfString("") + case "tibc.core.routing.v1.MsgSetRoutingRules.description": + return protoreflect.ValueOfString("") + case "tibc.core.routing.v1.MsgSetRoutingRules.rules": + list := []string{} + return protoreflect.ValueOfList(&_MsgSetRoutingRules_3_list{list: &list}) + case "tibc.core.routing.v1.MsgSetRoutingRules.authority": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.MsgSetRoutingRules")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.MsgSetRoutingRules 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_MsgSetRoutingRules) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.routing.v1.MsgSetRoutingRules", 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_MsgSetRoutingRules) 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_MsgSetRoutingRules) 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_MsgSetRoutingRules) 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_MsgSetRoutingRules) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgSetRoutingRules) + 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.Title) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Description) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.Rules) > 0 { + for _, s := range x.Rules { + l = len(s) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + l = len(x.Authority) + 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().(*MsgSetRoutingRules) + 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.Authority) > 0 { + i -= len(x.Authority) + copy(dAtA[i:], x.Authority) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority))) + i-- + dAtA[i] = 0x22 + } + if len(x.Rules) > 0 { + for iNdEx := len(x.Rules) - 1; iNdEx >= 0; iNdEx-- { + i -= len(x.Rules[iNdEx]) + copy(dAtA[i:], x.Rules[iNdEx]) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Rules[iNdEx]))) + i-- + dAtA[i] = 0x1a + } + } + if len(x.Description) > 0 { + i -= len(x.Description) + copy(dAtA[i:], x.Description) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Description))) + i-- + dAtA[i] = 0x12 + } + if len(x.Title) > 0 { + i -= len(x.Title) + copy(dAtA[i:], x.Title) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Title))) + 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().(*MsgSetRoutingRules) + 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: MsgSetRoutingRules: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSetRoutingRules: 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 Title", 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.Title = 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 Description", 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.Description = 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 Rules", 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.Rules = append(x.Rules, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", 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.Authority = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_MsgSetRoutingRulesResponse protoreflect.MessageDescriptor +) + +func init() { + file_tibc_core_routing_v1_tx_proto_init() + md_MsgSetRoutingRulesResponse = File_tibc_core_routing_v1_tx_proto.Messages().ByName("MsgSetRoutingRulesResponse") +} + +var _ protoreflect.Message = (*fastReflection_MsgSetRoutingRulesResponse)(nil) + +type fastReflection_MsgSetRoutingRulesResponse MsgSetRoutingRulesResponse + +func (x *MsgSetRoutingRulesResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgSetRoutingRulesResponse)(x) +} + +func (x *MsgSetRoutingRulesResponse) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_routing_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_MsgSetRoutingRulesResponse_messageType fastReflection_MsgSetRoutingRulesResponse_messageType +var _ protoreflect.MessageType = fastReflection_MsgSetRoutingRulesResponse_messageType{} + +type fastReflection_MsgSetRoutingRulesResponse_messageType struct{} + +func (x fastReflection_MsgSetRoutingRulesResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgSetRoutingRulesResponse)(nil) +} +func (x fastReflection_MsgSetRoutingRulesResponse_messageType) New() protoreflect.Message { + return new(fastReflection_MsgSetRoutingRulesResponse) +} +func (x fastReflection_MsgSetRoutingRulesResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgSetRoutingRulesResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgSetRoutingRulesResponse) Descriptor() protoreflect.MessageDescriptor { + return md_MsgSetRoutingRulesResponse +} + +// 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_MsgSetRoutingRulesResponse) Type() protoreflect.MessageType { + return _fastReflection_MsgSetRoutingRulesResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgSetRoutingRulesResponse) New() protoreflect.Message { + return new(fastReflection_MsgSetRoutingRulesResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgSetRoutingRulesResponse) Interface() protoreflect.ProtoMessage { + return (*MsgSetRoutingRulesResponse)(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_MsgSetRoutingRulesResponse) 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_MsgSetRoutingRulesResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.MsgSetRoutingRulesResponse")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.MsgSetRoutingRulesResponse 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_MsgSetRoutingRulesResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.MsgSetRoutingRulesResponse")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.MsgSetRoutingRulesResponse 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_MsgSetRoutingRulesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.MsgSetRoutingRulesResponse")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.MsgSetRoutingRulesResponse 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_MsgSetRoutingRulesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.MsgSetRoutingRulesResponse")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.MsgSetRoutingRulesResponse 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_MsgSetRoutingRulesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.MsgSetRoutingRulesResponse")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.MsgSetRoutingRulesResponse 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_MsgSetRoutingRulesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.routing.v1.MsgSetRoutingRulesResponse")) + } + panic(fmt.Errorf("message tibc.core.routing.v1.MsgSetRoutingRulesResponse 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_MsgSetRoutingRulesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.routing.v1.MsgSetRoutingRulesResponse", 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_MsgSetRoutingRulesResponse) 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_MsgSetRoutingRulesResponse) 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_MsgSetRoutingRulesResponse) 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_MsgSetRoutingRulesResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgSetRoutingRulesResponse) + 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().(*MsgSetRoutingRulesResponse) + 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().(*MsgSetRoutingRulesResponse) + 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: MsgSetRoutingRulesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSetRoutingRulesResponse: 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, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: tibc/core/routing/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) +) + +// MsgSetRoutingRules defines a proposal to set routing rules +type MsgSetRoutingRules struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // the title of the update proposal + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` + // the description of the proposal + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` + // routing rules list + Rules []string `protobuf:"bytes,3,rep,name=rules,proto3" json:"rules,omitempty"` + // authority is the address that controls the module (defaults to x/gov unless + // overwritten). + Authority string `protobuf:"bytes,4,opt,name=authority,proto3" json:"authority,omitempty"` +} + +func (x *MsgSetRoutingRules) Reset() { + *x = MsgSetRoutingRules{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_routing_v1_tx_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgSetRoutingRules) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgSetRoutingRules) ProtoMessage() {} + +// Deprecated: Use MsgSetRoutingRules.ProtoReflect.Descriptor instead. +func (*MsgSetRoutingRules) Descriptor() ([]byte, []int) { + return file_tibc_core_routing_v1_tx_proto_rawDescGZIP(), []int{0} +} + +func (x *MsgSetRoutingRules) GetTitle() string { + if x != nil { + return x.Title + } + return "" +} + +func (x *MsgSetRoutingRules) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +func (x *MsgSetRoutingRules) GetRules() []string { + if x != nil { + return x.Rules + } + return nil +} + +func (x *MsgSetRoutingRules) GetAuthority() string { + if x != nil { + return x.Authority + } + return "" +} + +// MsgSetRoutingRulesResponse defines the Msg/SetRoutingRules response type. +type MsgSetRoutingRulesResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *MsgSetRoutingRulesResponse) Reset() { + *x = MsgSetRoutingRulesResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_routing_v1_tx_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgSetRoutingRulesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgSetRoutingRulesResponse) ProtoMessage() {} + +// Deprecated: Use MsgSetRoutingRulesResponse.ProtoReflect.Descriptor instead. +func (*MsgSetRoutingRulesResponse) Descriptor() ([]byte, []int) { + return file_tibc_core_routing_v1_tx_proto_rawDescGZIP(), []int{1} +} + +var File_tibc_core_routing_v1_tx_proto protoreflect.FileDescriptor + +var file_tibc_core_routing_v1_tx_proto_rawDesc = []byte{ + 0x0a, 0x1d, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x72, 0x6f, 0x75, 0x74, + 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x2f, 0x74, 0x78, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, + 0x14, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x69, + 0x6e, 0x67, 0x2e, 0x76, 0x31, 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, 0x17, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6d, + 0x73, 0x67, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x73, 0x67, 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, 0x22, 0xab, 0x01, 0x0a, 0x12, 0x4d, + 0x73, 0x67, 0x53, 0x65, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, + 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x72, 0x75, 0x6c, + 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x12, + 0x36, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x04, 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, 0x61, 0x75, + 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x3a, 0x0f, 0x88, 0xa0, 0x1f, 0x00, 0x82, 0xe7, 0xb0, + 0x2a, 0x06, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x22, 0x1c, 0x0a, 0x1a, 0x4d, 0x73, 0x67, 0x53, + 0x65, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0x74, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x6d, 0x0a, + 0x0f, 0x53, 0x65, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, + 0x12, 0x28, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x72, 0x6f, 0x75, + 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x52, 0x6f, + 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x1a, 0x30, 0x2e, 0x74, 0x69, 0x62, + 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x76, + 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0xd7, 0x01, 0x0a, + 0x18, 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x72, + 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, + 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, + 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2d, + 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x3b, 0x72, 0x6f, 0x75, 0x74, + 0x69, 0x6e, 0x67, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x54, 0x43, 0x52, 0xaa, 0x02, 0x14, 0x54, 0x69, + 0x62, 0x63, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x2e, + 0x56, 0x31, 0xca, 0x02, 0x14, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x52, + 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x20, 0x54, 0x69, 0x62, 0x63, + 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5c, 0x56, 0x31, + 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x17, 0x54, + 0x69, 0x62, 0x63, 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x3a, 0x3a, 0x52, 0x6f, 0x75, 0x74, 0x69, + 0x6e, 0x67, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_core_routing_v1_tx_proto_rawDescOnce sync.Once + file_tibc_core_routing_v1_tx_proto_rawDescData = file_tibc_core_routing_v1_tx_proto_rawDesc +) + +func file_tibc_core_routing_v1_tx_proto_rawDescGZIP() []byte { + file_tibc_core_routing_v1_tx_proto_rawDescOnce.Do(func() { + file_tibc_core_routing_v1_tx_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_core_routing_v1_tx_proto_rawDescData) + }) + return file_tibc_core_routing_v1_tx_proto_rawDescData +} + +var file_tibc_core_routing_v1_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_tibc_core_routing_v1_tx_proto_goTypes = []interface{}{ + (*MsgSetRoutingRules)(nil), // 0: tibc.core.routing.v1.MsgSetRoutingRules + (*MsgSetRoutingRulesResponse)(nil), // 1: tibc.core.routing.v1.MsgSetRoutingRulesResponse +} +var file_tibc_core_routing_v1_tx_proto_depIdxs = []int32{ + 0, // 0: tibc.core.routing.v1.Msg.SetRoutingRules:input_type -> tibc.core.routing.v1.MsgSetRoutingRules + 1, // 1: tibc.core.routing.v1.Msg.SetRoutingRules:output_type -> tibc.core.routing.v1.MsgSetRoutingRulesResponse + 1, // [1:2] is the sub-list for method output_type + 0, // [0:1] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_tibc_core_routing_v1_tx_proto_init() } +func file_tibc_core_routing_v1_tx_proto_init() { + if File_tibc_core_routing_v1_tx_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_tibc_core_routing_v1_tx_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgSetRoutingRules); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_core_routing_v1_tx_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgSetRoutingRulesResponse); 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_tibc_core_routing_v1_tx_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_tibc_core_routing_v1_tx_proto_goTypes, + DependencyIndexes: file_tibc_core_routing_v1_tx_proto_depIdxs, + MessageInfos: file_tibc_core_routing_v1_tx_proto_msgTypes, + }.Build() + File_tibc_core_routing_v1_tx_proto = out.File + file_tibc_core_routing_v1_tx_proto_rawDesc = nil + file_tibc_core_routing_v1_tx_proto_goTypes = nil + file_tibc_core_routing_v1_tx_proto_depIdxs = nil +} diff --git a/api/tibc/core/routing/v1/tx_grpc.pb.go b/api/tibc/core/routing/v1/tx_grpc.pb.go new file mode 100644 index 00000000..a18d1a24 --- /dev/null +++ b/api/tibc/core/routing/v1/tx_grpc.pb.go @@ -0,0 +1,111 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: tibc/core/routing/v1/tx.proto + +package routingv1 + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + Msg_SetRoutingRules_FullMethodName = "/tibc.core.routing.v1.Msg/SetRoutingRules" +) + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type MsgClient interface { + // SetRoutingRules defines a rpc handler method for MsgSetRoutingRules. + SetRoutingRules(ctx context.Context, in *MsgSetRoutingRules, opts ...grpc.CallOption) (*MsgSetRoutingRulesResponse, error) +} + +type msgClient struct { + cc grpc.ClientConnInterface +} + +func NewMsgClient(cc grpc.ClientConnInterface) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) SetRoutingRules(ctx context.Context, in *MsgSetRoutingRules, opts ...grpc.CallOption) (*MsgSetRoutingRulesResponse, error) { + out := new(MsgSetRoutingRulesResponse) + err := c.cc.Invoke(ctx, Msg_SetRoutingRules_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +// All implementations must embed UnimplementedMsgServer +// for forward compatibility +type MsgServer interface { + // SetRoutingRules defines a rpc handler method for MsgSetRoutingRules. + SetRoutingRules(context.Context, *MsgSetRoutingRules) (*MsgSetRoutingRulesResponse, error) + mustEmbedUnimplementedMsgServer() +} + +// UnimplementedMsgServer must be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (UnimplementedMsgServer) SetRoutingRules(context.Context, *MsgSetRoutingRules) (*MsgSetRoutingRulesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SetRoutingRules not implemented") +} +func (UnimplementedMsgServer) mustEmbedUnimplementedMsgServer() {} + +// UnsafeMsgServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to MsgServer will +// result in compilation errors. +type UnsafeMsgServer interface { + mustEmbedUnimplementedMsgServer() +} + +func RegisterMsgServer(s grpc.ServiceRegistrar, srv MsgServer) { + s.RegisterService(&Msg_ServiceDesc, srv) +} + +func _Msg_SetRoutingRules_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgSetRoutingRules) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).SetRoutingRules(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Msg_SetRoutingRules_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).SetRoutingRules(ctx, req.(*MsgSetRoutingRules)) + } + return interceptor(ctx, in, info, handler) +} + +// Msg_ServiceDesc is the grpc.ServiceDesc for Msg service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Msg_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "tibc.core.routing.v1.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "SetRoutingRules", + Handler: _Msg_SetRoutingRules_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "tibc/core/routing/v1/tx.proto", +} diff --git a/api/tibc/core/types/v1/genesis.pulsar.go b/api/tibc/core/types/v1/genesis.pulsar.go new file mode 100644 index 00000000..c406246f --- /dev/null +++ b/api/tibc/core/types/v1/genesis.pulsar.go @@ -0,0 +1,798 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package typesv1 + +import ( + fmt "fmt" + v1 "github.com/bianjieai/tibc-go/api/tibc/core/client/v1" + v11 "github.com/bianjieai/tibc-go/api/tibc/core/packet/v1" + v12 "github.com/bianjieai/tibc-go/api/tibc/core/routing/v1" + 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" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_GenesisState protoreflect.MessageDescriptor + fd_GenesisState_client_genesis protoreflect.FieldDescriptor + fd_GenesisState_packet_genesis protoreflect.FieldDescriptor + fd_GenesisState_routing_genesis protoreflect.FieldDescriptor +) + +func init() { + file_tibc_core_types_v1_genesis_proto_init() + md_GenesisState = File_tibc_core_types_v1_genesis_proto.Messages().ByName("GenesisState") + fd_GenesisState_client_genesis = md_GenesisState.Fields().ByName("client_genesis") + fd_GenesisState_packet_genesis = md_GenesisState.Fields().ByName("packet_genesis") + fd_GenesisState_routing_genesis = md_GenesisState.Fields().ByName("routing_genesis") +} + +var _ protoreflect.Message = (*fastReflection_GenesisState)(nil) + +type fastReflection_GenesisState GenesisState + +func (x *GenesisState) ProtoReflect() protoreflect.Message { + return (*fastReflection_GenesisState)(x) +} + +func (x *GenesisState) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_core_types_v1_genesis_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_GenesisState_messageType fastReflection_GenesisState_messageType +var _ protoreflect.MessageType = fastReflection_GenesisState_messageType{} + +type fastReflection_GenesisState_messageType struct{} + +func (x fastReflection_GenesisState_messageType) Zero() protoreflect.Message { + return (*fastReflection_GenesisState)(nil) +} +func (x fastReflection_GenesisState_messageType) New() protoreflect.Message { + return new(fastReflection_GenesisState) +} +func (x fastReflection_GenesisState_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_GenesisState +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_GenesisState) Descriptor() protoreflect.MessageDescriptor { + return md_GenesisState +} + +// 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_GenesisState) Type() protoreflect.MessageType { + return _fastReflection_GenesisState_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_GenesisState) New() protoreflect.Message { + return new(fastReflection_GenesisState) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_GenesisState) Interface() protoreflect.ProtoMessage { + return (*GenesisState)(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_GenesisState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ClientGenesis != nil { + value := protoreflect.ValueOfMessage(x.ClientGenesis.ProtoReflect()) + if !f(fd_GenesisState_client_genesis, value) { + return + } + } + if x.PacketGenesis != nil { + value := protoreflect.ValueOfMessage(x.PacketGenesis.ProtoReflect()) + if !f(fd_GenesisState_packet_genesis, value) { + return + } + } + if x.RoutingGenesis != nil { + value := protoreflect.ValueOfMessage(x.RoutingGenesis.ProtoReflect()) + if !f(fd_GenesisState_routing_genesis, 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_GenesisState) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.core.types.v1.GenesisState.client_genesis": + return x.ClientGenesis != nil + case "tibc.core.types.v1.GenesisState.packet_genesis": + return x.PacketGenesis != nil + case "tibc.core.types.v1.GenesisState.routing_genesis": + return x.RoutingGenesis != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.types.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.types.v1.GenesisState 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_GenesisState) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.core.types.v1.GenesisState.client_genesis": + x.ClientGenesis = nil + case "tibc.core.types.v1.GenesisState.packet_genesis": + x.PacketGenesis = nil + case "tibc.core.types.v1.GenesisState.routing_genesis": + x.RoutingGenesis = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.types.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.types.v1.GenesisState 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_GenesisState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.core.types.v1.GenesisState.client_genesis": + value := x.ClientGenesis + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.types.v1.GenesisState.packet_genesis": + value := x.PacketGenesis + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.core.types.v1.GenesisState.routing_genesis": + value := x.RoutingGenesis + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.types.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.types.v1.GenesisState 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_GenesisState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.core.types.v1.GenesisState.client_genesis": + x.ClientGenesis = value.Message().Interface().(*v1.GenesisState) + case "tibc.core.types.v1.GenesisState.packet_genesis": + x.PacketGenesis = value.Message().Interface().(*v11.GenesisState) + case "tibc.core.types.v1.GenesisState.routing_genesis": + x.RoutingGenesis = value.Message().Interface().(*v12.GenesisState) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.types.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.types.v1.GenesisState 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_GenesisState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.types.v1.GenesisState.client_genesis": + if x.ClientGenesis == nil { + x.ClientGenesis = new(v1.GenesisState) + } + return protoreflect.ValueOfMessage(x.ClientGenesis.ProtoReflect()) + case "tibc.core.types.v1.GenesisState.packet_genesis": + if x.PacketGenesis == nil { + x.PacketGenesis = new(v11.GenesisState) + } + return protoreflect.ValueOfMessage(x.PacketGenesis.ProtoReflect()) + case "tibc.core.types.v1.GenesisState.routing_genesis": + if x.RoutingGenesis == nil { + x.RoutingGenesis = new(v12.GenesisState) + } + return protoreflect.ValueOfMessage(x.RoutingGenesis.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.types.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.types.v1.GenesisState 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_GenesisState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.core.types.v1.GenesisState.client_genesis": + m := new(v1.GenesisState) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.types.v1.GenesisState.packet_genesis": + m := new(v11.GenesisState) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.core.types.v1.GenesisState.routing_genesis": + m := new(v12.GenesisState) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.core.types.v1.GenesisState")) + } + panic(fmt.Errorf("message tibc.core.types.v1.GenesisState 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_GenesisState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.core.types.v1.GenesisState", 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_GenesisState) 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_GenesisState) 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_GenesisState) 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_GenesisState) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*GenesisState) + 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.ClientGenesis != nil { + l = options.Size(x.ClientGenesis) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.PacketGenesis != nil { + l = options.Size(x.PacketGenesis) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.RoutingGenesis != nil { + l = options.Size(x.RoutingGenesis) + 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().(*GenesisState) + 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.RoutingGenesis != nil { + encoded, err := options.Marshal(x.RoutingGenesis) + 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] = 0x22 + } + if x.PacketGenesis != nil { + encoded, err := options.Marshal(x.PacketGenesis) + 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.ClientGenesis != nil { + encoded, err := options.Marshal(x.ClientGenesis) + 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().(*GenesisState) + 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: GenesisState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GenesisState: 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 ClientGenesis", 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.ClientGenesis == nil { + x.ClientGenesis = &v1.GenesisState{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ClientGenesis); 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 PacketGenesis", 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.PacketGenesis == nil { + x.PacketGenesis = &v11.GenesisState{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PacketGenesis); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RoutingGenesis", 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.RoutingGenesis == nil { + x.RoutingGenesis = &v12.GenesisState{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.RoutingGenesis); 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: tibc/core/types/v1/genesis.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) +) + +// GenesisState defines the tibc module's genesis state. +type GenesisState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // TICS002 - Clients genesis state + ClientGenesis *v1.GenesisState `protobuf:"bytes,1,opt,name=client_genesis,json=clientGenesis,proto3" json:"client_genesis,omitempty"` + // TICS004 - Packet genesis state + PacketGenesis *v11.GenesisState `protobuf:"bytes,3,opt,name=packet_genesis,json=packetGenesis,proto3" json:"packet_genesis,omitempty"` + // TICS026 - Routing genesis state + RoutingGenesis *v12.GenesisState `protobuf:"bytes,4,opt,name=routing_genesis,json=routingGenesis,proto3" json:"routing_genesis,omitempty"` +} + +func (x *GenesisState) Reset() { + *x = GenesisState{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_core_types_v1_genesis_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GenesisState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GenesisState) ProtoMessage() {} + +// Deprecated: Use GenesisState.ProtoReflect.Descriptor instead. +func (*GenesisState) Descriptor() ([]byte, []int) { + return file_tibc_core_types_v1_genesis_proto_rawDescGZIP(), []int{0} +} + +func (x *GenesisState) GetClientGenesis() *v1.GenesisState { + if x != nil { + return x.ClientGenesis + } + return nil +} + +func (x *GenesisState) GetPacketGenesis() *v11.GenesisState { + if x != nil { + return x.PacketGenesis + } + return nil +} + +func (x *GenesisState) GetRoutingGenesis() *v12.GenesisState { + if x != nil { + return x.RoutingGenesis + } + return nil +} + +var File_tibc_core_types_v1_genesis_proto protoreflect.FileDescriptor + +var file_tibc_core_types_v1_genesis_proto_rawDesc = []byte{ + 0x0a, 0x20, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x79, 0x70, 0x65, + 0x73, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x12, 0x12, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x74, 0x79, + 0x70, 0x65, 0x73, 0x2e, 0x76, 0x31, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x74, 0x69, + 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x76, + 0x31, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, + 0x21, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x65, + 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x22, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x72, 0x6f, + 0x75, 0x74, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xcd, 0x02, 0x0a, 0x0c, 0x47, 0x65, 0x6e, 0x65, 0x73, + 0x69, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x67, 0x0a, 0x0e, 0x63, 0x6c, 0x69, 0x65, 0x6e, + 0x74, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x21, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x53, 0x74, 0x61, + 0x74, 0x65, 0x42, 0x1d, 0xc8, 0xde, 0x1f, 0x00, 0xf2, 0xde, 0x1f, 0x15, 0x79, 0x61, 0x6d, 0x6c, + 0x3a, 0x22, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, + 0x22, 0x52, 0x0d, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, + 0x12, 0x67, 0x0a, 0x0e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x73, + 0x69, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x47, + 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x42, 0x1d, 0xc8, 0xde, 0x1f, + 0x00, 0xf2, 0xde, 0x1f, 0x15, 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x70, 0x61, 0x63, 0x6b, 0x65, + 0x74, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x22, 0x52, 0x0d, 0x70, 0x61, 0x63, 0x6b, + 0x65, 0x74, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x12, 0x6b, 0x0a, 0x0f, 0x72, 0x6f, 0x75, + 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x72, + 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, + 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x42, 0x1e, 0xc8, 0xde, 0x1f, 0x00, 0xf2, 0xde, 0x1f, 0x16, + 0x79, 0x61, 0x6d, 0x6c, 0x3a, 0x22, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x67, 0x65, + 0x6e, 0x65, 0x73, 0x69, 0x73, 0x22, 0x52, 0x0e, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x47, + 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x42, 0xce, 0x01, 0x0a, 0x16, 0x63, 0x6f, 0x6d, 0x2e, 0x74, + 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x76, + 0x31, 0x42, 0x0c, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, + 0x01, 0x5a, 0x3b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x62, 0x69, + 0x61, 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2d, 0x67, 0x6f, 0x2f, + 0x61, 0x70, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x79, + 0x70, 0x65, 0x73, 0x2f, 0x76, 0x31, 0x3b, 0x74, 0x79, 0x70, 0x65, 0x73, 0x76, 0x31, 0xa2, 0x02, + 0x03, 0x54, 0x43, 0x54, 0xaa, 0x02, 0x12, 0x54, 0x69, 0x62, 0x63, 0x2e, 0x43, 0x6f, 0x72, 0x65, + 0x2e, 0x54, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x12, 0x54, 0x69, 0x62, 0x63, + 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x5c, 0x56, 0x31, 0xe2, 0x02, + 0x1e, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x54, 0x79, 0x70, 0x65, 0x73, + 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, + 0x02, 0x15, 0x54, 0x69, 0x62, 0x63, 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x3a, 0x3a, 0x54, 0x79, + 0x70, 0x65, 0x73, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_core_types_v1_genesis_proto_rawDescOnce sync.Once + file_tibc_core_types_v1_genesis_proto_rawDescData = file_tibc_core_types_v1_genesis_proto_rawDesc +) + +func file_tibc_core_types_v1_genesis_proto_rawDescGZIP() []byte { + file_tibc_core_types_v1_genesis_proto_rawDescOnce.Do(func() { + file_tibc_core_types_v1_genesis_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_core_types_v1_genesis_proto_rawDescData) + }) + return file_tibc_core_types_v1_genesis_proto_rawDescData +} + +var file_tibc_core_types_v1_genesis_proto_msgTypes = make([]protoimpl.MessageInfo, 1) +var file_tibc_core_types_v1_genesis_proto_goTypes = []interface{}{ + (*GenesisState)(nil), // 0: tibc.core.types.v1.GenesisState + (*v1.GenesisState)(nil), // 1: tibc.core.client.v1.GenesisState + (*v11.GenesisState)(nil), // 2: tibc.core.packet.v1.GenesisState + (*v12.GenesisState)(nil), // 3: tibc.core.routing.v1.GenesisState +} +var file_tibc_core_types_v1_genesis_proto_depIdxs = []int32{ + 1, // 0: tibc.core.types.v1.GenesisState.client_genesis:type_name -> tibc.core.client.v1.GenesisState + 2, // 1: tibc.core.types.v1.GenesisState.packet_genesis:type_name -> tibc.core.packet.v1.GenesisState + 3, // 2: tibc.core.types.v1.GenesisState.routing_genesis:type_name -> tibc.core.routing.v1.GenesisState + 3, // [3:3] is the sub-list for method output_type + 3, // [3:3] is the sub-list for method input_type + 3, // [3:3] is the sub-list for extension type_name + 3, // [3:3] is the sub-list for extension extendee + 0, // [0:3] is the sub-list for field type_name +} + +func init() { file_tibc_core_types_v1_genesis_proto_init() } +func file_tibc_core_types_v1_genesis_proto_init() { + if File_tibc_core_types_v1_genesis_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_tibc_core_types_v1_genesis_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GenesisState); 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_tibc_core_types_v1_genesis_proto_rawDesc, + NumEnums: 0, + NumMessages: 1, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_tibc_core_types_v1_genesis_proto_goTypes, + DependencyIndexes: file_tibc_core_types_v1_genesis_proto_depIdxs, + MessageInfos: file_tibc_core_types_v1_genesis_proto_msgTypes, + }.Build() + File_tibc_core_types_v1_genesis_proto = out.File + file_tibc_core_types_v1_genesis_proto_rawDesc = nil + file_tibc_core_types_v1_genesis_proto_goTypes = nil + file_tibc_core_types_v1_genesis_proto_depIdxs = nil +} diff --git a/api/tibc/lightclients/bsc/v1/bsc.pulsar.go b/api/tibc/lightclients/bsc/v1/bsc.pulsar.go new file mode 100644 index 00000000..923d0475 --- /dev/null +++ b/api/tibc/lightclients/bsc/v1/bsc.pulsar.go @@ -0,0 +1,6668 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package bscv1 + +import ( + fmt "fmt" + v1 "github.com/bianjieai/tibc-go/api/tibc/core/client/v1" + 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" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_Header protoreflect.MessageDescriptor + fd_Header_parent_hash protoreflect.FieldDescriptor + fd_Header_uncle_hash protoreflect.FieldDescriptor + fd_Header_coinbase protoreflect.FieldDescriptor + fd_Header_root protoreflect.FieldDescriptor + fd_Header_tx_hash protoreflect.FieldDescriptor + fd_Header_receipt_hash protoreflect.FieldDescriptor + fd_Header_bloom protoreflect.FieldDescriptor + fd_Header_difficulty protoreflect.FieldDescriptor + fd_Header_height protoreflect.FieldDescriptor + fd_Header_gas_limit protoreflect.FieldDescriptor + fd_Header_gas_used protoreflect.FieldDescriptor + fd_Header_time protoreflect.FieldDescriptor + fd_Header_extra protoreflect.FieldDescriptor + fd_Header_mix_digest protoreflect.FieldDescriptor + fd_Header_nonce protoreflect.FieldDescriptor +) + +func init() { + file_tibc_lightclients_bsc_v1_bsc_proto_init() + md_Header = File_tibc_lightclients_bsc_v1_bsc_proto.Messages().ByName("Header") + fd_Header_parent_hash = md_Header.Fields().ByName("parent_hash") + fd_Header_uncle_hash = md_Header.Fields().ByName("uncle_hash") + fd_Header_coinbase = md_Header.Fields().ByName("coinbase") + fd_Header_root = md_Header.Fields().ByName("root") + fd_Header_tx_hash = md_Header.Fields().ByName("tx_hash") + fd_Header_receipt_hash = md_Header.Fields().ByName("receipt_hash") + fd_Header_bloom = md_Header.Fields().ByName("bloom") + fd_Header_difficulty = md_Header.Fields().ByName("difficulty") + fd_Header_height = md_Header.Fields().ByName("height") + fd_Header_gas_limit = md_Header.Fields().ByName("gas_limit") + fd_Header_gas_used = md_Header.Fields().ByName("gas_used") + fd_Header_time = md_Header.Fields().ByName("time") + fd_Header_extra = md_Header.Fields().ByName("extra") + fd_Header_mix_digest = md_Header.Fields().ByName("mix_digest") + fd_Header_nonce = md_Header.Fields().ByName("nonce") +} + +var _ protoreflect.Message = (*fastReflection_Header)(nil) + +type fastReflection_Header Header + +func (x *Header) ProtoReflect() protoreflect.Message { + return (*fastReflection_Header)(x) +} + +func (x *Header) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_lightclients_bsc_v1_bsc_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_Header_messageType fastReflection_Header_messageType +var _ protoreflect.MessageType = fastReflection_Header_messageType{} + +type fastReflection_Header_messageType struct{} + +func (x fastReflection_Header_messageType) Zero() protoreflect.Message { + return (*fastReflection_Header)(nil) +} +func (x fastReflection_Header_messageType) New() protoreflect.Message { + return new(fastReflection_Header) +} +func (x fastReflection_Header_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Header +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Header) Descriptor() protoreflect.MessageDescriptor { + return md_Header +} + +// 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_Header) Type() protoreflect.MessageType { + return _fastReflection_Header_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Header) New() protoreflect.Message { + return new(fastReflection_Header) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Header) Interface() protoreflect.ProtoMessage { + return (*Header)(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_Header) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.ParentHash) != 0 { + value := protoreflect.ValueOfBytes(x.ParentHash) + if !f(fd_Header_parent_hash, value) { + return + } + } + if len(x.UncleHash) != 0 { + value := protoreflect.ValueOfBytes(x.UncleHash) + if !f(fd_Header_uncle_hash, value) { + return + } + } + if len(x.Coinbase) != 0 { + value := protoreflect.ValueOfBytes(x.Coinbase) + if !f(fd_Header_coinbase, value) { + return + } + } + if len(x.Root) != 0 { + value := protoreflect.ValueOfBytes(x.Root) + if !f(fd_Header_root, value) { + return + } + } + if len(x.TxHash) != 0 { + value := protoreflect.ValueOfBytes(x.TxHash) + if !f(fd_Header_tx_hash, value) { + return + } + } + if len(x.ReceiptHash) != 0 { + value := protoreflect.ValueOfBytes(x.ReceiptHash) + if !f(fd_Header_receipt_hash, value) { + return + } + } + if len(x.Bloom) != 0 { + value := protoreflect.ValueOfBytes(x.Bloom) + if !f(fd_Header_bloom, value) { + return + } + } + if x.Difficulty != uint64(0) { + value := protoreflect.ValueOfUint64(x.Difficulty) + if !f(fd_Header_difficulty, value) { + return + } + } + if x.Height != nil { + value := protoreflect.ValueOfMessage(x.Height.ProtoReflect()) + if !f(fd_Header_height, value) { + return + } + } + if x.GasLimit != uint64(0) { + value := protoreflect.ValueOfUint64(x.GasLimit) + if !f(fd_Header_gas_limit, value) { + return + } + } + if x.GasUsed != uint64(0) { + value := protoreflect.ValueOfUint64(x.GasUsed) + if !f(fd_Header_gas_used, value) { + return + } + } + if x.Time != uint64(0) { + value := protoreflect.ValueOfUint64(x.Time) + if !f(fd_Header_time, value) { + return + } + } + if len(x.Extra) != 0 { + value := protoreflect.ValueOfBytes(x.Extra) + if !f(fd_Header_extra, value) { + return + } + } + if len(x.MixDigest) != 0 { + value := protoreflect.ValueOfBytes(x.MixDigest) + if !f(fd_Header_mix_digest, value) { + return + } + } + if len(x.Nonce) != 0 { + value := protoreflect.ValueOfBytes(x.Nonce) + if !f(fd_Header_nonce, 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_Header) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.Header.parent_hash": + return len(x.ParentHash) != 0 + case "tibc.lightclients.bsc.v1.Header.uncle_hash": + return len(x.UncleHash) != 0 + case "tibc.lightclients.bsc.v1.Header.coinbase": + return len(x.Coinbase) != 0 + case "tibc.lightclients.bsc.v1.Header.root": + return len(x.Root) != 0 + case "tibc.lightclients.bsc.v1.Header.tx_hash": + return len(x.TxHash) != 0 + case "tibc.lightclients.bsc.v1.Header.receipt_hash": + return len(x.ReceiptHash) != 0 + case "tibc.lightclients.bsc.v1.Header.bloom": + return len(x.Bloom) != 0 + case "tibc.lightclients.bsc.v1.Header.difficulty": + return x.Difficulty != uint64(0) + case "tibc.lightclients.bsc.v1.Header.height": + return x.Height != nil + case "tibc.lightclients.bsc.v1.Header.gas_limit": + return x.GasLimit != uint64(0) + case "tibc.lightclients.bsc.v1.Header.gas_used": + return x.GasUsed != uint64(0) + case "tibc.lightclients.bsc.v1.Header.time": + return x.Time != uint64(0) + case "tibc.lightclients.bsc.v1.Header.extra": + return len(x.Extra) != 0 + case "tibc.lightclients.bsc.v1.Header.mix_digest": + return len(x.MixDigest) != 0 + case "tibc.lightclients.bsc.v1.Header.nonce": + return len(x.Nonce) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.Header")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.Header 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_Header) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.Header.parent_hash": + x.ParentHash = nil + case "tibc.lightclients.bsc.v1.Header.uncle_hash": + x.UncleHash = nil + case "tibc.lightclients.bsc.v1.Header.coinbase": + x.Coinbase = nil + case "tibc.lightclients.bsc.v1.Header.root": + x.Root = nil + case "tibc.lightclients.bsc.v1.Header.tx_hash": + x.TxHash = nil + case "tibc.lightclients.bsc.v1.Header.receipt_hash": + x.ReceiptHash = nil + case "tibc.lightclients.bsc.v1.Header.bloom": + x.Bloom = nil + case "tibc.lightclients.bsc.v1.Header.difficulty": + x.Difficulty = uint64(0) + case "tibc.lightclients.bsc.v1.Header.height": + x.Height = nil + case "tibc.lightclients.bsc.v1.Header.gas_limit": + x.GasLimit = uint64(0) + case "tibc.lightclients.bsc.v1.Header.gas_used": + x.GasUsed = uint64(0) + case "tibc.lightclients.bsc.v1.Header.time": + x.Time = uint64(0) + case "tibc.lightclients.bsc.v1.Header.extra": + x.Extra = nil + case "tibc.lightclients.bsc.v1.Header.mix_digest": + x.MixDigest = nil + case "tibc.lightclients.bsc.v1.Header.nonce": + x.Nonce = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.Header")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.Header 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_Header) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.lightclients.bsc.v1.Header.parent_hash": + value := x.ParentHash + return protoreflect.ValueOfBytes(value) + case "tibc.lightclients.bsc.v1.Header.uncle_hash": + value := x.UncleHash + return protoreflect.ValueOfBytes(value) + case "tibc.lightclients.bsc.v1.Header.coinbase": + value := x.Coinbase + return protoreflect.ValueOfBytes(value) + case "tibc.lightclients.bsc.v1.Header.root": + value := x.Root + return protoreflect.ValueOfBytes(value) + case "tibc.lightclients.bsc.v1.Header.tx_hash": + value := x.TxHash + return protoreflect.ValueOfBytes(value) + case "tibc.lightclients.bsc.v1.Header.receipt_hash": + value := x.ReceiptHash + return protoreflect.ValueOfBytes(value) + case "tibc.lightclients.bsc.v1.Header.bloom": + value := x.Bloom + return protoreflect.ValueOfBytes(value) + case "tibc.lightclients.bsc.v1.Header.difficulty": + value := x.Difficulty + return protoreflect.ValueOfUint64(value) + case "tibc.lightclients.bsc.v1.Header.height": + value := x.Height + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.lightclients.bsc.v1.Header.gas_limit": + value := x.GasLimit + return protoreflect.ValueOfUint64(value) + case "tibc.lightclients.bsc.v1.Header.gas_used": + value := x.GasUsed + return protoreflect.ValueOfUint64(value) + case "tibc.lightclients.bsc.v1.Header.time": + value := x.Time + return protoreflect.ValueOfUint64(value) + case "tibc.lightclients.bsc.v1.Header.extra": + value := x.Extra + return protoreflect.ValueOfBytes(value) + case "tibc.lightclients.bsc.v1.Header.mix_digest": + value := x.MixDigest + return protoreflect.ValueOfBytes(value) + case "tibc.lightclients.bsc.v1.Header.nonce": + value := x.Nonce + return protoreflect.ValueOfBytes(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.Header")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.Header 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_Header) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.Header.parent_hash": + x.ParentHash = value.Bytes() + case "tibc.lightclients.bsc.v1.Header.uncle_hash": + x.UncleHash = value.Bytes() + case "tibc.lightclients.bsc.v1.Header.coinbase": + x.Coinbase = value.Bytes() + case "tibc.lightclients.bsc.v1.Header.root": + x.Root = value.Bytes() + case "tibc.lightclients.bsc.v1.Header.tx_hash": + x.TxHash = value.Bytes() + case "tibc.lightclients.bsc.v1.Header.receipt_hash": + x.ReceiptHash = value.Bytes() + case "tibc.lightclients.bsc.v1.Header.bloom": + x.Bloom = value.Bytes() + case "tibc.lightclients.bsc.v1.Header.difficulty": + x.Difficulty = value.Uint() + case "tibc.lightclients.bsc.v1.Header.height": + x.Height = value.Message().Interface().(*v1.Height) + case "tibc.lightclients.bsc.v1.Header.gas_limit": + x.GasLimit = value.Uint() + case "tibc.lightclients.bsc.v1.Header.gas_used": + x.GasUsed = value.Uint() + case "tibc.lightclients.bsc.v1.Header.time": + x.Time = value.Uint() + case "tibc.lightclients.bsc.v1.Header.extra": + x.Extra = value.Bytes() + case "tibc.lightclients.bsc.v1.Header.mix_digest": + x.MixDigest = value.Bytes() + case "tibc.lightclients.bsc.v1.Header.nonce": + x.Nonce = value.Bytes() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.Header")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.Header 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_Header) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.Header.height": + if x.Height == nil { + x.Height = new(v1.Height) + } + return protoreflect.ValueOfMessage(x.Height.ProtoReflect()) + case "tibc.lightclients.bsc.v1.Header.parent_hash": + panic(fmt.Errorf("field parent_hash of message tibc.lightclients.bsc.v1.Header is not mutable")) + case "tibc.lightclients.bsc.v1.Header.uncle_hash": + panic(fmt.Errorf("field uncle_hash of message tibc.lightclients.bsc.v1.Header is not mutable")) + case "tibc.lightclients.bsc.v1.Header.coinbase": + panic(fmt.Errorf("field coinbase of message tibc.lightclients.bsc.v1.Header is not mutable")) + case "tibc.lightclients.bsc.v1.Header.root": + panic(fmt.Errorf("field root of message tibc.lightclients.bsc.v1.Header is not mutable")) + case "tibc.lightclients.bsc.v1.Header.tx_hash": + panic(fmt.Errorf("field tx_hash of message tibc.lightclients.bsc.v1.Header is not mutable")) + case "tibc.lightclients.bsc.v1.Header.receipt_hash": + panic(fmt.Errorf("field receipt_hash of message tibc.lightclients.bsc.v1.Header is not mutable")) + case "tibc.lightclients.bsc.v1.Header.bloom": + panic(fmt.Errorf("field bloom of message tibc.lightclients.bsc.v1.Header is not mutable")) + case "tibc.lightclients.bsc.v1.Header.difficulty": + panic(fmt.Errorf("field difficulty of message tibc.lightclients.bsc.v1.Header is not mutable")) + case "tibc.lightclients.bsc.v1.Header.gas_limit": + panic(fmt.Errorf("field gas_limit of message tibc.lightclients.bsc.v1.Header is not mutable")) + case "tibc.lightclients.bsc.v1.Header.gas_used": + panic(fmt.Errorf("field gas_used of message tibc.lightclients.bsc.v1.Header is not mutable")) + case "tibc.lightclients.bsc.v1.Header.time": + panic(fmt.Errorf("field time of message tibc.lightclients.bsc.v1.Header is not mutable")) + case "tibc.lightclients.bsc.v1.Header.extra": + panic(fmt.Errorf("field extra of message tibc.lightclients.bsc.v1.Header is not mutable")) + case "tibc.lightclients.bsc.v1.Header.mix_digest": + panic(fmt.Errorf("field mix_digest of message tibc.lightclients.bsc.v1.Header is not mutable")) + case "tibc.lightclients.bsc.v1.Header.nonce": + panic(fmt.Errorf("field nonce of message tibc.lightclients.bsc.v1.Header is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.Header")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.Header 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_Header) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.Header.parent_hash": + return protoreflect.ValueOfBytes(nil) + case "tibc.lightclients.bsc.v1.Header.uncle_hash": + return protoreflect.ValueOfBytes(nil) + case "tibc.lightclients.bsc.v1.Header.coinbase": + return protoreflect.ValueOfBytes(nil) + case "tibc.lightclients.bsc.v1.Header.root": + return protoreflect.ValueOfBytes(nil) + case "tibc.lightclients.bsc.v1.Header.tx_hash": + return protoreflect.ValueOfBytes(nil) + case "tibc.lightclients.bsc.v1.Header.receipt_hash": + return protoreflect.ValueOfBytes(nil) + case "tibc.lightclients.bsc.v1.Header.bloom": + return protoreflect.ValueOfBytes(nil) + case "tibc.lightclients.bsc.v1.Header.difficulty": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.lightclients.bsc.v1.Header.height": + m := new(v1.Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.lightclients.bsc.v1.Header.gas_limit": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.lightclients.bsc.v1.Header.gas_used": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.lightclients.bsc.v1.Header.time": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.lightclients.bsc.v1.Header.extra": + return protoreflect.ValueOfBytes(nil) + case "tibc.lightclients.bsc.v1.Header.mix_digest": + return protoreflect.ValueOfBytes(nil) + case "tibc.lightclients.bsc.v1.Header.nonce": + return protoreflect.ValueOfBytes(nil) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.Header")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.Header 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_Header) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.lightclients.bsc.v1.Header", 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_Header) 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_Header) 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_Header) 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_Header) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Header) + 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.ParentHash) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.UncleHash) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Coinbase) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Root) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.TxHash) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.ReceiptHash) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Bloom) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Difficulty != 0 { + n += 1 + runtime.Sov(uint64(x.Difficulty)) + } + if x.Height != nil { + l = options.Size(x.Height) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.GasLimit != 0 { + n += 1 + runtime.Sov(uint64(x.GasLimit)) + } + if x.GasUsed != 0 { + n += 1 + runtime.Sov(uint64(x.GasUsed)) + } + if x.Time != 0 { + n += 1 + runtime.Sov(uint64(x.Time)) + } + l = len(x.Extra) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.MixDigest) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Nonce) + 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().(*Header) + 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.Nonce) > 0 { + i -= len(x.Nonce) + copy(dAtA[i:], x.Nonce) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Nonce))) + i-- + dAtA[i] = 0x7a + } + if len(x.MixDigest) > 0 { + i -= len(x.MixDigest) + copy(dAtA[i:], x.MixDigest) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MixDigest))) + i-- + dAtA[i] = 0x72 + } + if len(x.Extra) > 0 { + i -= len(x.Extra) + copy(dAtA[i:], x.Extra) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Extra))) + i-- + dAtA[i] = 0x6a + } + if x.Time != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Time)) + i-- + dAtA[i] = 0x60 + } + if x.GasUsed != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.GasUsed)) + i-- + dAtA[i] = 0x58 + } + if x.GasLimit != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.GasLimit)) + i-- + dAtA[i] = 0x50 + } + if x.Height != nil { + encoded, err := options.Marshal(x.Height) + 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] = 0x4a + } + if x.Difficulty != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Difficulty)) + i-- + dAtA[i] = 0x40 + } + if len(x.Bloom) > 0 { + i -= len(x.Bloom) + copy(dAtA[i:], x.Bloom) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Bloom))) + i-- + dAtA[i] = 0x3a + } + if len(x.ReceiptHash) > 0 { + i -= len(x.ReceiptHash) + copy(dAtA[i:], x.ReceiptHash) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ReceiptHash))) + i-- + dAtA[i] = 0x32 + } + if len(x.TxHash) > 0 { + i -= len(x.TxHash) + copy(dAtA[i:], x.TxHash) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.TxHash))) + i-- + dAtA[i] = 0x2a + } + if len(x.Root) > 0 { + i -= len(x.Root) + copy(dAtA[i:], x.Root) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Root))) + i-- + dAtA[i] = 0x22 + } + if len(x.Coinbase) > 0 { + i -= len(x.Coinbase) + copy(dAtA[i:], x.Coinbase) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Coinbase))) + i-- + dAtA[i] = 0x1a + } + if len(x.UncleHash) > 0 { + i -= len(x.UncleHash) + copy(dAtA[i:], x.UncleHash) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.UncleHash))) + i-- + dAtA[i] = 0x12 + } + if len(x.ParentHash) > 0 { + i -= len(x.ParentHash) + copy(dAtA[i:], x.ParentHash) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ParentHash))) + 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().(*Header) + 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: Header: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Header: 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 ParentHash", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.ParentHash = append(x.ParentHash[:0], dAtA[iNdEx:postIndex]...) + if x.ParentHash == nil { + x.ParentHash = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UncleHash", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.UncleHash = append(x.UncleHash[:0], dAtA[iNdEx:postIndex]...) + if x.UncleHash == nil { + x.UncleHash = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Coinbase", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Coinbase = append(x.Coinbase[:0], dAtA[iNdEx:postIndex]...) + if x.Coinbase == nil { + x.Coinbase = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Root", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Root = append(x.Root[:0], dAtA[iNdEx:postIndex]...) + if x.Root == nil { + x.Root = []byte{} + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TxHash", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.TxHash = append(x.TxHash[:0], dAtA[iNdEx:postIndex]...) + if x.TxHash == nil { + x.TxHash = []byte{} + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ReceiptHash", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.ReceiptHash = append(x.ReceiptHash[:0], dAtA[iNdEx:postIndex]...) + if x.ReceiptHash == nil { + x.ReceiptHash = []byte{} + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Bloom", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Bloom = append(x.Bloom[:0], dAtA[iNdEx:postIndex]...) + if x.Bloom == nil { + x.Bloom = []byte{} + } + iNdEx = postIndex + case 8: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Difficulty", wireType) + } + x.Difficulty = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Difficulty |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Height", 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.Height == nil { + x.Height = &v1.Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Height); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 10: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + x.GasLimit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.GasLimit |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 11: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + x.GasUsed = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.GasUsed |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 12: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Time", wireType) + } + x.Time = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Time |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 13: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Extra", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Extra = append(x.Extra[:0], dAtA[iNdEx:postIndex]...) + if x.Extra == nil { + x.Extra = []byte{} + } + iNdEx = postIndex + case 14: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MixDigest", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.MixDigest = append(x.MixDigest[:0], dAtA[iNdEx:postIndex]...) + if x.MixDigest == nil { + x.MixDigest = []byte{} + } + iNdEx = postIndex + case 15: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Nonce = append(x.Nonce[:0], dAtA[iNdEx:postIndex]...) + if x.Nonce == nil { + x.Nonce = []byte{} + } + 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 = (*_ClientState_5_list)(nil) + +type _ClientState_5_list struct { + list *[][]byte +} + +func (x *_ClientState_5_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_ClientState_5_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfBytes((*x.list)[i]) +} + +func (x *_ClientState_5_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Bytes() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_ClientState_5_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Bytes() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_ClientState_5_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message ClientState at list field Validators as it is not of Message kind")) +} + +func (x *_ClientState_5_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_ClientState_5_list) NewElement() protoreflect.Value { + var v []byte + return protoreflect.ValueOfBytes(v) +} + +func (x *_ClientState_5_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_ClientState_6_list)(nil) + +type _ClientState_6_list struct { + list *[]*Signer +} + +func (x *_ClientState_6_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_ClientState_6_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_ClientState_6_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*Signer) + (*x.list)[i] = concreteValue +} + +func (x *_ClientState_6_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*Signer) + *x.list = append(*x.list, concreteValue) +} + +func (x *_ClientState_6_list) AppendMutable() protoreflect.Value { + v := new(Signer) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_ClientState_6_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_ClientState_6_list) NewElement() protoreflect.Value { + v := new(Signer) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_ClientState_6_list) IsValid() bool { + return x.list != nil +} + +var ( + md_ClientState protoreflect.MessageDescriptor + fd_ClientState_header protoreflect.FieldDescriptor + fd_ClientState_chain_id protoreflect.FieldDescriptor + fd_ClientState_epoch protoreflect.FieldDescriptor + fd_ClientState_block_inteval protoreflect.FieldDescriptor + fd_ClientState_validators protoreflect.FieldDescriptor + fd_ClientState_recent_signers protoreflect.FieldDescriptor + fd_ClientState_contract_address protoreflect.FieldDescriptor + fd_ClientState_trusting_period protoreflect.FieldDescriptor +) + +func init() { + file_tibc_lightclients_bsc_v1_bsc_proto_init() + md_ClientState = File_tibc_lightclients_bsc_v1_bsc_proto.Messages().ByName("ClientState") + fd_ClientState_header = md_ClientState.Fields().ByName("header") + fd_ClientState_chain_id = md_ClientState.Fields().ByName("chain_id") + fd_ClientState_epoch = md_ClientState.Fields().ByName("epoch") + fd_ClientState_block_inteval = md_ClientState.Fields().ByName("block_inteval") + fd_ClientState_validators = md_ClientState.Fields().ByName("validators") + fd_ClientState_recent_signers = md_ClientState.Fields().ByName("recent_signers") + fd_ClientState_contract_address = md_ClientState.Fields().ByName("contract_address") + fd_ClientState_trusting_period = md_ClientState.Fields().ByName("trusting_period") +} + +var _ protoreflect.Message = (*fastReflection_ClientState)(nil) + +type fastReflection_ClientState ClientState + +func (x *ClientState) ProtoReflect() protoreflect.Message { + return (*fastReflection_ClientState)(x) +} + +func (x *ClientState) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_lightclients_bsc_v1_bsc_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_ClientState_messageType fastReflection_ClientState_messageType +var _ protoreflect.MessageType = fastReflection_ClientState_messageType{} + +type fastReflection_ClientState_messageType struct{} + +func (x fastReflection_ClientState_messageType) Zero() protoreflect.Message { + return (*fastReflection_ClientState)(nil) +} +func (x fastReflection_ClientState_messageType) New() protoreflect.Message { + return new(fastReflection_ClientState) +} +func (x fastReflection_ClientState_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_ClientState +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_ClientState) Descriptor() protoreflect.MessageDescriptor { + return md_ClientState +} + +// 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_ClientState) Type() protoreflect.MessageType { + return _fastReflection_ClientState_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_ClientState) New() protoreflect.Message { + return new(fastReflection_ClientState) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_ClientState) Interface() protoreflect.ProtoMessage { + return (*ClientState)(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_ClientState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Header != nil { + value := protoreflect.ValueOfMessage(x.Header.ProtoReflect()) + if !f(fd_ClientState_header, value) { + return + } + } + if x.ChainId != uint64(0) { + value := protoreflect.ValueOfUint64(x.ChainId) + if !f(fd_ClientState_chain_id, value) { + return + } + } + if x.Epoch != uint64(0) { + value := protoreflect.ValueOfUint64(x.Epoch) + if !f(fd_ClientState_epoch, value) { + return + } + } + if x.BlockInteval != uint64(0) { + value := protoreflect.ValueOfUint64(x.BlockInteval) + if !f(fd_ClientState_block_inteval, value) { + return + } + } + if len(x.Validators) != 0 { + value := protoreflect.ValueOfList(&_ClientState_5_list{list: &x.Validators}) + if !f(fd_ClientState_validators, value) { + return + } + } + if len(x.RecentSigners) != 0 { + value := protoreflect.ValueOfList(&_ClientState_6_list{list: &x.RecentSigners}) + if !f(fd_ClientState_recent_signers, value) { + return + } + } + if len(x.ContractAddress) != 0 { + value := protoreflect.ValueOfBytes(x.ContractAddress) + if !f(fd_ClientState_contract_address, value) { + return + } + } + if x.TrustingPeriod != uint64(0) { + value := protoreflect.ValueOfUint64(x.TrustingPeriod) + if !f(fd_ClientState_trusting_period, 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_ClientState) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.ClientState.header": + return x.Header != nil + case "tibc.lightclients.bsc.v1.ClientState.chain_id": + return x.ChainId != uint64(0) + case "tibc.lightclients.bsc.v1.ClientState.epoch": + return x.Epoch != uint64(0) + case "tibc.lightclients.bsc.v1.ClientState.block_inteval": + return x.BlockInteval != uint64(0) + case "tibc.lightclients.bsc.v1.ClientState.validators": + return len(x.Validators) != 0 + case "tibc.lightclients.bsc.v1.ClientState.recent_signers": + return len(x.RecentSigners) != 0 + case "tibc.lightclients.bsc.v1.ClientState.contract_address": + return len(x.ContractAddress) != 0 + case "tibc.lightclients.bsc.v1.ClientState.trusting_period": + return x.TrustingPeriod != uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.ClientState")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.ClientState 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_ClientState) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.ClientState.header": + x.Header = nil + case "tibc.lightclients.bsc.v1.ClientState.chain_id": + x.ChainId = uint64(0) + case "tibc.lightclients.bsc.v1.ClientState.epoch": + x.Epoch = uint64(0) + case "tibc.lightclients.bsc.v1.ClientState.block_inteval": + x.BlockInteval = uint64(0) + case "tibc.lightclients.bsc.v1.ClientState.validators": + x.Validators = nil + case "tibc.lightclients.bsc.v1.ClientState.recent_signers": + x.RecentSigners = nil + case "tibc.lightclients.bsc.v1.ClientState.contract_address": + x.ContractAddress = nil + case "tibc.lightclients.bsc.v1.ClientState.trusting_period": + x.TrustingPeriod = uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.ClientState")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.ClientState 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_ClientState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.lightclients.bsc.v1.ClientState.header": + value := x.Header + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.lightclients.bsc.v1.ClientState.chain_id": + value := x.ChainId + return protoreflect.ValueOfUint64(value) + case "tibc.lightclients.bsc.v1.ClientState.epoch": + value := x.Epoch + return protoreflect.ValueOfUint64(value) + case "tibc.lightclients.bsc.v1.ClientState.block_inteval": + value := x.BlockInteval + return protoreflect.ValueOfUint64(value) + case "tibc.lightclients.bsc.v1.ClientState.validators": + if len(x.Validators) == 0 { + return protoreflect.ValueOfList(&_ClientState_5_list{}) + } + listValue := &_ClientState_5_list{list: &x.Validators} + return protoreflect.ValueOfList(listValue) + case "tibc.lightclients.bsc.v1.ClientState.recent_signers": + if len(x.RecentSigners) == 0 { + return protoreflect.ValueOfList(&_ClientState_6_list{}) + } + listValue := &_ClientState_6_list{list: &x.RecentSigners} + return protoreflect.ValueOfList(listValue) + case "tibc.lightclients.bsc.v1.ClientState.contract_address": + value := x.ContractAddress + return protoreflect.ValueOfBytes(value) + case "tibc.lightclients.bsc.v1.ClientState.trusting_period": + value := x.TrustingPeriod + return protoreflect.ValueOfUint64(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.ClientState")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.ClientState 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_ClientState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.ClientState.header": + x.Header = value.Message().Interface().(*Header) + case "tibc.lightclients.bsc.v1.ClientState.chain_id": + x.ChainId = value.Uint() + case "tibc.lightclients.bsc.v1.ClientState.epoch": + x.Epoch = value.Uint() + case "tibc.lightclients.bsc.v1.ClientState.block_inteval": + x.BlockInteval = value.Uint() + case "tibc.lightclients.bsc.v1.ClientState.validators": + lv := value.List() + clv := lv.(*_ClientState_5_list) + x.Validators = *clv.list + case "tibc.lightclients.bsc.v1.ClientState.recent_signers": + lv := value.List() + clv := lv.(*_ClientState_6_list) + x.RecentSigners = *clv.list + case "tibc.lightclients.bsc.v1.ClientState.contract_address": + x.ContractAddress = value.Bytes() + case "tibc.lightclients.bsc.v1.ClientState.trusting_period": + x.TrustingPeriod = value.Uint() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.ClientState")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.ClientState 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_ClientState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.ClientState.header": + if x.Header == nil { + x.Header = new(Header) + } + return protoreflect.ValueOfMessage(x.Header.ProtoReflect()) + case "tibc.lightclients.bsc.v1.ClientState.validators": + if x.Validators == nil { + x.Validators = [][]byte{} + } + value := &_ClientState_5_list{list: &x.Validators} + return protoreflect.ValueOfList(value) + case "tibc.lightclients.bsc.v1.ClientState.recent_signers": + if x.RecentSigners == nil { + x.RecentSigners = []*Signer{} + } + value := &_ClientState_6_list{list: &x.RecentSigners} + return protoreflect.ValueOfList(value) + case "tibc.lightclients.bsc.v1.ClientState.chain_id": + panic(fmt.Errorf("field chain_id of message tibc.lightclients.bsc.v1.ClientState is not mutable")) + case "tibc.lightclients.bsc.v1.ClientState.epoch": + panic(fmt.Errorf("field epoch of message tibc.lightclients.bsc.v1.ClientState is not mutable")) + case "tibc.lightclients.bsc.v1.ClientState.block_inteval": + panic(fmt.Errorf("field block_inteval of message tibc.lightclients.bsc.v1.ClientState is not mutable")) + case "tibc.lightclients.bsc.v1.ClientState.contract_address": + panic(fmt.Errorf("field contract_address of message tibc.lightclients.bsc.v1.ClientState is not mutable")) + case "tibc.lightclients.bsc.v1.ClientState.trusting_period": + panic(fmt.Errorf("field trusting_period of message tibc.lightclients.bsc.v1.ClientState is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.ClientState")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.ClientState 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_ClientState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.ClientState.header": + m := new(Header) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.lightclients.bsc.v1.ClientState.chain_id": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.lightclients.bsc.v1.ClientState.epoch": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.lightclients.bsc.v1.ClientState.block_inteval": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.lightclients.bsc.v1.ClientState.validators": + list := [][]byte{} + return protoreflect.ValueOfList(&_ClientState_5_list{list: &list}) + case "tibc.lightclients.bsc.v1.ClientState.recent_signers": + list := []*Signer{} + return protoreflect.ValueOfList(&_ClientState_6_list{list: &list}) + case "tibc.lightclients.bsc.v1.ClientState.contract_address": + return protoreflect.ValueOfBytes(nil) + case "tibc.lightclients.bsc.v1.ClientState.trusting_period": + return protoreflect.ValueOfUint64(uint64(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.ClientState")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.ClientState 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_ClientState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.lightclients.bsc.v1.ClientState", 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_ClientState) 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_ClientState) 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_ClientState) 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_ClientState) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*ClientState) + 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.Header != nil { + l = options.Size(x.Header) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ChainId != 0 { + n += 1 + runtime.Sov(uint64(x.ChainId)) + } + if x.Epoch != 0 { + n += 1 + runtime.Sov(uint64(x.Epoch)) + } + if x.BlockInteval != 0 { + n += 1 + runtime.Sov(uint64(x.BlockInteval)) + } + if len(x.Validators) > 0 { + for _, b := range x.Validators { + l = len(b) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if len(x.RecentSigners) > 0 { + for _, e := range x.RecentSigners { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + l = len(x.ContractAddress) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.TrustingPeriod != 0 { + n += 1 + runtime.Sov(uint64(x.TrustingPeriod)) + } + 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().(*ClientState) + 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.TrustingPeriod != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.TrustingPeriod)) + i-- + dAtA[i] = 0x40 + } + if len(x.ContractAddress) > 0 { + i -= len(x.ContractAddress) + copy(dAtA[i:], x.ContractAddress) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ContractAddress))) + i-- + dAtA[i] = 0x3a + } + if len(x.RecentSigners) > 0 { + for iNdEx := len(x.RecentSigners) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.RecentSigners[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] = 0x32 + } + } + if len(x.Validators) > 0 { + for iNdEx := len(x.Validators) - 1; iNdEx >= 0; iNdEx-- { + i -= len(x.Validators[iNdEx]) + copy(dAtA[i:], x.Validators[iNdEx]) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Validators[iNdEx]))) + i-- + dAtA[i] = 0x2a + } + } + if x.BlockInteval != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockInteval)) + i-- + dAtA[i] = 0x20 + } + if x.Epoch != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Epoch)) + i-- + dAtA[i] = 0x18 + } + if x.ChainId != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.ChainId)) + i-- + dAtA[i] = 0x10 + } + if x.Header != nil { + encoded, err := options.Marshal(x.Header) + 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().(*ClientState) + 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: ClientState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ClientState: 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 Header", 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.Header == nil { + x.Header = &Header{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Header); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + x.ChainId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.ChainId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + x.Epoch = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Epoch |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockInteval", wireType) + } + x.BlockInteval = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.BlockInteval |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Validators = append(x.Validators, make([]byte, postIndex-iNdEx)) + copy(x.Validators[len(x.Validators)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RecentSigners", 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.RecentSigners = append(x.RecentSigners, &Signer{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.RecentSigners[len(x.RecentSigners)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.ContractAddress = append(x.ContractAddress[:0], dAtA[iNdEx:postIndex]...) + if x.ContractAddress == nil { + x.ContractAddress = []byte{} + } + iNdEx = postIndex + case 8: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TrustingPeriod", wireType) + } + x.TrustingPeriod = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.TrustingPeriod |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_Signer protoreflect.MessageDescriptor + fd_Signer_height protoreflect.FieldDescriptor + fd_Signer_validator protoreflect.FieldDescriptor +) + +func init() { + file_tibc_lightclients_bsc_v1_bsc_proto_init() + md_Signer = File_tibc_lightclients_bsc_v1_bsc_proto.Messages().ByName("Signer") + fd_Signer_height = md_Signer.Fields().ByName("height") + fd_Signer_validator = md_Signer.Fields().ByName("validator") +} + +var _ protoreflect.Message = (*fastReflection_Signer)(nil) + +type fastReflection_Signer Signer + +func (x *Signer) ProtoReflect() protoreflect.Message { + return (*fastReflection_Signer)(x) +} + +func (x *Signer) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_lightclients_bsc_v1_bsc_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_Signer_messageType fastReflection_Signer_messageType +var _ protoreflect.MessageType = fastReflection_Signer_messageType{} + +type fastReflection_Signer_messageType struct{} + +func (x fastReflection_Signer_messageType) Zero() protoreflect.Message { + return (*fastReflection_Signer)(nil) +} +func (x fastReflection_Signer_messageType) New() protoreflect.Message { + return new(fastReflection_Signer) +} +func (x fastReflection_Signer_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Signer +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Signer) Descriptor() protoreflect.MessageDescriptor { + return md_Signer +} + +// 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_Signer) Type() protoreflect.MessageType { + return _fastReflection_Signer_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Signer) New() protoreflect.Message { + return new(fastReflection_Signer) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Signer) Interface() protoreflect.ProtoMessage { + return (*Signer)(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_Signer) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Height != nil { + value := protoreflect.ValueOfMessage(x.Height.ProtoReflect()) + if !f(fd_Signer_height, value) { + return + } + } + if len(x.Validator) != 0 { + value := protoreflect.ValueOfBytes(x.Validator) + if !f(fd_Signer_validator, 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_Signer) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.Signer.height": + return x.Height != nil + case "tibc.lightclients.bsc.v1.Signer.validator": + return len(x.Validator) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.Signer")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.Signer 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_Signer) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.Signer.height": + x.Height = nil + case "tibc.lightclients.bsc.v1.Signer.validator": + x.Validator = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.Signer")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.Signer 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_Signer) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.lightclients.bsc.v1.Signer.height": + value := x.Height + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.lightclients.bsc.v1.Signer.validator": + value := x.Validator + return protoreflect.ValueOfBytes(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.Signer")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.Signer 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_Signer) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.Signer.height": + x.Height = value.Message().Interface().(*v1.Height) + case "tibc.lightclients.bsc.v1.Signer.validator": + x.Validator = value.Bytes() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.Signer")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.Signer 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_Signer) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.Signer.height": + if x.Height == nil { + x.Height = new(v1.Height) + } + return protoreflect.ValueOfMessage(x.Height.ProtoReflect()) + case "tibc.lightclients.bsc.v1.Signer.validator": + panic(fmt.Errorf("field validator of message tibc.lightclients.bsc.v1.Signer is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.Signer")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.Signer 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_Signer) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.Signer.height": + m := new(v1.Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.lightclients.bsc.v1.Signer.validator": + return protoreflect.ValueOfBytes(nil) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.Signer")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.Signer 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_Signer) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.lightclients.bsc.v1.Signer", 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_Signer) 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_Signer) 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_Signer) 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_Signer) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Signer) + 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.Height != nil { + l = options.Size(x.Height) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Validator) + 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().(*Signer) + 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.Validator) > 0 { + i -= len(x.Validator) + copy(dAtA[i:], x.Validator) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Validator))) + i-- + dAtA[i] = 0x12 + } + if x.Height != nil { + encoded, err := options.Marshal(x.Height) + 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().(*Signer) + 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: Signer: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Signer: 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 Height", 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.Height == nil { + x.Height = &v1.Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Height); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Validator = append(x.Validator[:0], dAtA[iNdEx:postIndex]...) + if x.Validator == nil { + x.Validator = []byte{} + } + 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 = (*_SignerSet_1_list)(nil) + +type _SignerSet_1_list struct { + list *[]*Signer +} + +func (x *_SignerSet_1_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_SignerSet_1_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_SignerSet_1_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*Signer) + (*x.list)[i] = concreteValue +} + +func (x *_SignerSet_1_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*Signer) + *x.list = append(*x.list, concreteValue) +} + +func (x *_SignerSet_1_list) AppendMutable() protoreflect.Value { + v := new(Signer) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_SignerSet_1_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_SignerSet_1_list) NewElement() protoreflect.Value { + v := new(Signer) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_SignerSet_1_list) IsValid() bool { + return x.list != nil +} + +var ( + md_SignerSet protoreflect.MessageDescriptor + fd_SignerSet_signers protoreflect.FieldDescriptor +) + +func init() { + file_tibc_lightclients_bsc_v1_bsc_proto_init() + md_SignerSet = File_tibc_lightclients_bsc_v1_bsc_proto.Messages().ByName("SignerSet") + fd_SignerSet_signers = md_SignerSet.Fields().ByName("signers") +} + +var _ protoreflect.Message = (*fastReflection_SignerSet)(nil) + +type fastReflection_SignerSet SignerSet + +func (x *SignerSet) ProtoReflect() protoreflect.Message { + return (*fastReflection_SignerSet)(x) +} + +func (x *SignerSet) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_lightclients_bsc_v1_bsc_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_SignerSet_messageType fastReflection_SignerSet_messageType +var _ protoreflect.MessageType = fastReflection_SignerSet_messageType{} + +type fastReflection_SignerSet_messageType struct{} + +func (x fastReflection_SignerSet_messageType) Zero() protoreflect.Message { + return (*fastReflection_SignerSet)(nil) +} +func (x fastReflection_SignerSet_messageType) New() protoreflect.Message { + return new(fastReflection_SignerSet) +} +func (x fastReflection_SignerSet_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_SignerSet +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_SignerSet) Descriptor() protoreflect.MessageDescriptor { + return md_SignerSet +} + +// 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_SignerSet) Type() protoreflect.MessageType { + return _fastReflection_SignerSet_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_SignerSet) New() protoreflect.Message { + return new(fastReflection_SignerSet) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_SignerSet) Interface() protoreflect.ProtoMessage { + return (*SignerSet)(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_SignerSet) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.Signers) != 0 { + value := protoreflect.ValueOfList(&_SignerSet_1_list{list: &x.Signers}) + if !f(fd_SignerSet_signers, 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_SignerSet) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.SignerSet.signers": + return len(x.Signers) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.SignerSet")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.SignerSet 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_SignerSet) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.SignerSet.signers": + x.Signers = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.SignerSet")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.SignerSet 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_SignerSet) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.lightclients.bsc.v1.SignerSet.signers": + if len(x.Signers) == 0 { + return protoreflect.ValueOfList(&_SignerSet_1_list{}) + } + listValue := &_SignerSet_1_list{list: &x.Signers} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.SignerSet")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.SignerSet 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_SignerSet) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.SignerSet.signers": + lv := value.List() + clv := lv.(*_SignerSet_1_list) + x.Signers = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.SignerSet")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.SignerSet 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_SignerSet) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.SignerSet.signers": + if x.Signers == nil { + x.Signers = []*Signer{} + } + value := &_SignerSet_1_list{list: &x.Signers} + return protoreflect.ValueOfList(value) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.SignerSet")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.SignerSet 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_SignerSet) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.SignerSet.signers": + list := []*Signer{} + return protoreflect.ValueOfList(&_SignerSet_1_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.SignerSet")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.SignerSet 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_SignerSet) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.lightclients.bsc.v1.SignerSet", 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_SignerSet) 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_SignerSet) 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_SignerSet) 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_SignerSet) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*SignerSet) + 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.Signers) > 0 { + for _, e := range x.Signers { + 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().(*SignerSet) + 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.Signers) > 0 { + for iNdEx := len(x.Signers) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.Signers[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().(*SignerSet) + 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: SignerSet: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: SignerSet: 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 Signers", 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.Signers = append(x.Signers, &Signer{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Signers[len(x.Signers)-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 = (*_ValidatorSet_1_list)(nil) + +type _ValidatorSet_1_list struct { + list *[][]byte +} + +func (x *_ValidatorSet_1_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_ValidatorSet_1_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfBytes((*x.list)[i]) +} + +func (x *_ValidatorSet_1_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Bytes() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_ValidatorSet_1_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Bytes() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_ValidatorSet_1_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message ValidatorSet at list field Validators as it is not of Message kind")) +} + +func (x *_ValidatorSet_1_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_ValidatorSet_1_list) NewElement() protoreflect.Value { + var v []byte + return protoreflect.ValueOfBytes(v) +} + +func (x *_ValidatorSet_1_list) IsValid() bool { + return x.list != nil +} + +var ( + md_ValidatorSet protoreflect.MessageDescriptor + fd_ValidatorSet_validators protoreflect.FieldDescriptor +) + +func init() { + file_tibc_lightclients_bsc_v1_bsc_proto_init() + md_ValidatorSet = File_tibc_lightclients_bsc_v1_bsc_proto.Messages().ByName("ValidatorSet") + fd_ValidatorSet_validators = md_ValidatorSet.Fields().ByName("validators") +} + +var _ protoreflect.Message = (*fastReflection_ValidatorSet)(nil) + +type fastReflection_ValidatorSet ValidatorSet + +func (x *ValidatorSet) ProtoReflect() protoreflect.Message { + return (*fastReflection_ValidatorSet)(x) +} + +func (x *ValidatorSet) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_lightclients_bsc_v1_bsc_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_ValidatorSet_messageType fastReflection_ValidatorSet_messageType +var _ protoreflect.MessageType = fastReflection_ValidatorSet_messageType{} + +type fastReflection_ValidatorSet_messageType struct{} + +func (x fastReflection_ValidatorSet_messageType) Zero() protoreflect.Message { + return (*fastReflection_ValidatorSet)(nil) +} +func (x fastReflection_ValidatorSet_messageType) New() protoreflect.Message { + return new(fastReflection_ValidatorSet) +} +func (x fastReflection_ValidatorSet_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_ValidatorSet +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_ValidatorSet) Descriptor() protoreflect.MessageDescriptor { + return md_ValidatorSet +} + +// 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_ValidatorSet) Type() protoreflect.MessageType { + return _fastReflection_ValidatorSet_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_ValidatorSet) New() protoreflect.Message { + return new(fastReflection_ValidatorSet) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_ValidatorSet) Interface() protoreflect.ProtoMessage { + return (*ValidatorSet)(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_ValidatorSet) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.Validators) != 0 { + value := protoreflect.ValueOfList(&_ValidatorSet_1_list{list: &x.Validators}) + if !f(fd_ValidatorSet_validators, 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_ValidatorSet) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.ValidatorSet.validators": + return len(x.Validators) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.ValidatorSet")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.ValidatorSet 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_ValidatorSet) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.ValidatorSet.validators": + x.Validators = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.ValidatorSet")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.ValidatorSet 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_ValidatorSet) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.lightclients.bsc.v1.ValidatorSet.validators": + if len(x.Validators) == 0 { + return protoreflect.ValueOfList(&_ValidatorSet_1_list{}) + } + listValue := &_ValidatorSet_1_list{list: &x.Validators} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.ValidatorSet")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.ValidatorSet 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_ValidatorSet) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.ValidatorSet.validators": + lv := value.List() + clv := lv.(*_ValidatorSet_1_list) + x.Validators = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.ValidatorSet")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.ValidatorSet 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_ValidatorSet) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.ValidatorSet.validators": + if x.Validators == nil { + x.Validators = [][]byte{} + } + value := &_ValidatorSet_1_list{list: &x.Validators} + return protoreflect.ValueOfList(value) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.ValidatorSet")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.ValidatorSet 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_ValidatorSet) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.ValidatorSet.validators": + list := [][]byte{} + return protoreflect.ValueOfList(&_ValidatorSet_1_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.ValidatorSet")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.ValidatorSet 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_ValidatorSet) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.lightclients.bsc.v1.ValidatorSet", 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_ValidatorSet) 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_ValidatorSet) 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_ValidatorSet) 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_ValidatorSet) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*ValidatorSet) + 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.Validators) > 0 { + for _, b := range x.Validators { + l = len(b) + 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().(*ValidatorSet) + 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.Validators) > 0 { + for iNdEx := len(x.Validators) - 1; iNdEx >= 0; iNdEx-- { + i -= len(x.Validators[iNdEx]) + copy(dAtA[i:], x.Validators[iNdEx]) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Validators[iNdEx]))) + 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().(*ValidatorSet) + 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: ValidatorSet: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ValidatorSet: 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 Validators", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Validators = append(x.Validators, make([]byte, postIndex-iNdEx)) + copy(x.Validators[len(x.Validators)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_ConsensusState protoreflect.MessageDescriptor + fd_ConsensusState_timestamp protoreflect.FieldDescriptor + fd_ConsensusState_number protoreflect.FieldDescriptor + fd_ConsensusState_root protoreflect.FieldDescriptor +) + +func init() { + file_tibc_lightclients_bsc_v1_bsc_proto_init() + md_ConsensusState = File_tibc_lightclients_bsc_v1_bsc_proto.Messages().ByName("ConsensusState") + fd_ConsensusState_timestamp = md_ConsensusState.Fields().ByName("timestamp") + fd_ConsensusState_number = md_ConsensusState.Fields().ByName("number") + fd_ConsensusState_root = md_ConsensusState.Fields().ByName("root") +} + +var _ protoreflect.Message = (*fastReflection_ConsensusState)(nil) + +type fastReflection_ConsensusState ConsensusState + +func (x *ConsensusState) ProtoReflect() protoreflect.Message { + return (*fastReflection_ConsensusState)(x) +} + +func (x *ConsensusState) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_lightclients_bsc_v1_bsc_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_ConsensusState_messageType fastReflection_ConsensusState_messageType +var _ protoreflect.MessageType = fastReflection_ConsensusState_messageType{} + +type fastReflection_ConsensusState_messageType struct{} + +func (x fastReflection_ConsensusState_messageType) Zero() protoreflect.Message { + return (*fastReflection_ConsensusState)(nil) +} +func (x fastReflection_ConsensusState_messageType) New() protoreflect.Message { + return new(fastReflection_ConsensusState) +} +func (x fastReflection_ConsensusState_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_ConsensusState +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_ConsensusState) Descriptor() protoreflect.MessageDescriptor { + return md_ConsensusState +} + +// 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_ConsensusState) Type() protoreflect.MessageType { + return _fastReflection_ConsensusState_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_ConsensusState) New() protoreflect.Message { + return new(fastReflection_ConsensusState) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_ConsensusState) Interface() protoreflect.ProtoMessage { + return (*ConsensusState)(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_ConsensusState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Timestamp != uint64(0) { + value := protoreflect.ValueOfUint64(x.Timestamp) + if !f(fd_ConsensusState_timestamp, value) { + return + } + } + if x.Number != nil { + value := protoreflect.ValueOfMessage(x.Number.ProtoReflect()) + if !f(fd_ConsensusState_number, value) { + return + } + } + if len(x.Root) != 0 { + value := protoreflect.ValueOfBytes(x.Root) + if !f(fd_ConsensusState_root, 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_ConsensusState) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.ConsensusState.timestamp": + return x.Timestamp != uint64(0) + case "tibc.lightclients.bsc.v1.ConsensusState.number": + return x.Number != nil + case "tibc.lightclients.bsc.v1.ConsensusState.root": + return len(x.Root) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.ConsensusState")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.ConsensusState 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_ConsensusState) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.ConsensusState.timestamp": + x.Timestamp = uint64(0) + case "tibc.lightclients.bsc.v1.ConsensusState.number": + x.Number = nil + case "tibc.lightclients.bsc.v1.ConsensusState.root": + x.Root = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.ConsensusState")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.ConsensusState 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_ConsensusState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.lightclients.bsc.v1.ConsensusState.timestamp": + value := x.Timestamp + return protoreflect.ValueOfUint64(value) + case "tibc.lightclients.bsc.v1.ConsensusState.number": + value := x.Number + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.lightclients.bsc.v1.ConsensusState.root": + value := x.Root + return protoreflect.ValueOfBytes(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.ConsensusState")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.ConsensusState 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_ConsensusState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.ConsensusState.timestamp": + x.Timestamp = value.Uint() + case "tibc.lightclients.bsc.v1.ConsensusState.number": + x.Number = value.Message().Interface().(*v1.Height) + case "tibc.lightclients.bsc.v1.ConsensusState.root": + x.Root = value.Bytes() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.ConsensusState")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.ConsensusState 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_ConsensusState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.ConsensusState.number": + if x.Number == nil { + x.Number = new(v1.Height) + } + return protoreflect.ValueOfMessage(x.Number.ProtoReflect()) + case "tibc.lightclients.bsc.v1.ConsensusState.timestamp": + panic(fmt.Errorf("field timestamp of message tibc.lightclients.bsc.v1.ConsensusState is not mutable")) + case "tibc.lightclients.bsc.v1.ConsensusState.root": + panic(fmt.Errorf("field root of message tibc.lightclients.bsc.v1.ConsensusState is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.ConsensusState")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.ConsensusState 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_ConsensusState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.ConsensusState.timestamp": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.lightclients.bsc.v1.ConsensusState.number": + m := new(v1.Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.lightclients.bsc.v1.ConsensusState.root": + return protoreflect.ValueOfBytes(nil) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.ConsensusState")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.ConsensusState 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_ConsensusState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.lightclients.bsc.v1.ConsensusState", 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_ConsensusState) 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_ConsensusState) 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_ConsensusState) 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_ConsensusState) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*ConsensusState) + 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.Timestamp != 0 { + n += 1 + runtime.Sov(uint64(x.Timestamp)) + } + if x.Number != nil { + l = options.Size(x.Number) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Root) + 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().(*ConsensusState) + 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.Root) > 0 { + i -= len(x.Root) + copy(dAtA[i:], x.Root) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Root))) + i-- + dAtA[i] = 0x1a + } + if x.Number != nil { + encoded, err := options.Marshal(x.Number) + 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 x.Timestamp != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Timestamp)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*ConsensusState) + 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: ConsensusState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ConsensusState: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + x.Timestamp = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Timestamp |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Number", 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.Number == nil { + x.Number = &v1.Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Number); 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 Root", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Root = append(x.Root[:0], dAtA[iNdEx:postIndex]...) + if x.Root == nil { + x.Root = []byte{} + } + 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 = (*_StorageResult_3_list)(nil) + +type _StorageResult_3_list struct { + list *[]string +} + +func (x *_StorageResult_3_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_StorageResult_3_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfString((*x.list)[i]) +} + +func (x *_StorageResult_3_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_StorageResult_3_list) Append(value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_StorageResult_3_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message StorageResult at list field Proof as it is not of Message kind")) +} + +func (x *_StorageResult_3_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_StorageResult_3_list) NewElement() protoreflect.Value { + v := "" + return protoreflect.ValueOfString(v) +} + +func (x *_StorageResult_3_list) IsValid() bool { + return x.list != nil +} + +var ( + md_StorageResult protoreflect.MessageDescriptor + fd_StorageResult_key protoreflect.FieldDescriptor + fd_StorageResult_value protoreflect.FieldDescriptor + fd_StorageResult_proof protoreflect.FieldDescriptor +) + +func init() { + file_tibc_lightclients_bsc_v1_bsc_proto_init() + md_StorageResult = File_tibc_lightclients_bsc_v1_bsc_proto.Messages().ByName("StorageResult") + fd_StorageResult_key = md_StorageResult.Fields().ByName("key") + fd_StorageResult_value = md_StorageResult.Fields().ByName("value") + fd_StorageResult_proof = md_StorageResult.Fields().ByName("proof") +} + +var _ protoreflect.Message = (*fastReflection_StorageResult)(nil) + +type fastReflection_StorageResult StorageResult + +func (x *StorageResult) ProtoReflect() protoreflect.Message { + return (*fastReflection_StorageResult)(x) +} + +func (x *StorageResult) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_lightclients_bsc_v1_bsc_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_StorageResult_messageType fastReflection_StorageResult_messageType +var _ protoreflect.MessageType = fastReflection_StorageResult_messageType{} + +type fastReflection_StorageResult_messageType struct{} + +func (x fastReflection_StorageResult_messageType) Zero() protoreflect.Message { + return (*fastReflection_StorageResult)(nil) +} +func (x fastReflection_StorageResult_messageType) New() protoreflect.Message { + return new(fastReflection_StorageResult) +} +func (x fastReflection_StorageResult_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_StorageResult +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_StorageResult) Descriptor() protoreflect.MessageDescriptor { + return md_StorageResult +} + +// 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_StorageResult) Type() protoreflect.MessageType { + return _fastReflection_StorageResult_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_StorageResult) New() protoreflect.Message { + return new(fastReflection_StorageResult) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_StorageResult) Interface() protoreflect.ProtoMessage { + return (*StorageResult)(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_StorageResult) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Key != "" { + value := protoreflect.ValueOfString(x.Key) + if !f(fd_StorageResult_key, value) { + return + } + } + if x.Value != "" { + value := protoreflect.ValueOfString(x.Value) + if !f(fd_StorageResult_value, value) { + return + } + } + if len(x.Proof) != 0 { + value := protoreflect.ValueOfList(&_StorageResult_3_list{list: &x.Proof}) + if !f(fd_StorageResult_proof, 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_StorageResult) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.StorageResult.key": + return x.Key != "" + case "tibc.lightclients.bsc.v1.StorageResult.value": + return x.Value != "" + case "tibc.lightclients.bsc.v1.StorageResult.proof": + return len(x.Proof) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.StorageResult")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.StorageResult 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_StorageResult) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.StorageResult.key": + x.Key = "" + case "tibc.lightclients.bsc.v1.StorageResult.value": + x.Value = "" + case "tibc.lightclients.bsc.v1.StorageResult.proof": + x.Proof = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.StorageResult")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.StorageResult 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_StorageResult) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.lightclients.bsc.v1.StorageResult.key": + value := x.Key + return protoreflect.ValueOfString(value) + case "tibc.lightclients.bsc.v1.StorageResult.value": + value := x.Value + return protoreflect.ValueOfString(value) + case "tibc.lightclients.bsc.v1.StorageResult.proof": + if len(x.Proof) == 0 { + return protoreflect.ValueOfList(&_StorageResult_3_list{}) + } + listValue := &_StorageResult_3_list{list: &x.Proof} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.StorageResult")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.StorageResult 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_StorageResult) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.StorageResult.key": + x.Key = value.Interface().(string) + case "tibc.lightclients.bsc.v1.StorageResult.value": + x.Value = value.Interface().(string) + case "tibc.lightclients.bsc.v1.StorageResult.proof": + lv := value.List() + clv := lv.(*_StorageResult_3_list) + x.Proof = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.StorageResult")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.StorageResult 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_StorageResult) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.StorageResult.proof": + if x.Proof == nil { + x.Proof = []string{} + } + value := &_StorageResult_3_list{list: &x.Proof} + return protoreflect.ValueOfList(value) + case "tibc.lightclients.bsc.v1.StorageResult.key": + panic(fmt.Errorf("field key of message tibc.lightclients.bsc.v1.StorageResult is not mutable")) + case "tibc.lightclients.bsc.v1.StorageResult.value": + panic(fmt.Errorf("field value of message tibc.lightclients.bsc.v1.StorageResult is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.StorageResult")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.StorageResult 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_StorageResult) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.StorageResult.key": + return protoreflect.ValueOfString("") + case "tibc.lightclients.bsc.v1.StorageResult.value": + return protoreflect.ValueOfString("") + case "tibc.lightclients.bsc.v1.StorageResult.proof": + list := []string{} + return protoreflect.ValueOfList(&_StorageResult_3_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.StorageResult")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.StorageResult 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_StorageResult) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.lightclients.bsc.v1.StorageResult", 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_StorageResult) 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_StorageResult) 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_StorageResult) 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_StorageResult) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*StorageResult) + 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.Key) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Value) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.Proof) > 0 { + for _, s := range x.Proof { + l = len(s) + 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().(*StorageResult) + 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.Proof) > 0 { + for iNdEx := len(x.Proof) - 1; iNdEx >= 0; iNdEx-- { + i -= len(x.Proof[iNdEx]) + copy(dAtA[i:], x.Proof[iNdEx]) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Proof[iNdEx]))) + i-- + dAtA[i] = 0x1a + } + } + if len(x.Value) > 0 { + i -= len(x.Value) + copy(dAtA[i:], x.Value) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Value))) + i-- + dAtA[i] = 0x12 + } + if len(x.Key) > 0 { + i -= len(x.Key) + copy(dAtA[i:], x.Key) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Key))) + 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().(*StorageResult) + 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: StorageResult: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: StorageResult: 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 Key", 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.Key = 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 Value", 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.Value = 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 Proof", 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.Proof = append(x.Proof, 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 = (*_Proof_6_list)(nil) + +type _Proof_6_list struct { + list *[]string +} + +func (x *_Proof_6_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_Proof_6_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfString((*x.list)[i]) +} + +func (x *_Proof_6_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_Proof_6_list) Append(value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_Proof_6_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message Proof at list field AccountProof as it is not of Message kind")) +} + +func (x *_Proof_6_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_Proof_6_list) NewElement() protoreflect.Value { + v := "" + return protoreflect.ValueOfString(v) +} + +func (x *_Proof_6_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_Proof_7_list)(nil) + +type _Proof_7_list struct { + list *[]*StorageResult +} + +func (x *_Proof_7_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_Proof_7_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_Proof_7_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*StorageResult) + (*x.list)[i] = concreteValue +} + +func (x *_Proof_7_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*StorageResult) + *x.list = append(*x.list, concreteValue) +} + +func (x *_Proof_7_list) AppendMutable() protoreflect.Value { + v := new(StorageResult) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_Proof_7_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_Proof_7_list) NewElement() protoreflect.Value { + v := new(StorageResult) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_Proof_7_list) IsValid() bool { + return x.list != nil +} + +var ( + md_Proof protoreflect.MessageDescriptor + fd_Proof_address protoreflect.FieldDescriptor + fd_Proof_balance protoreflect.FieldDescriptor + fd_Proof_code_hash protoreflect.FieldDescriptor + fd_Proof_nonce protoreflect.FieldDescriptor + fd_Proof_storage_hash protoreflect.FieldDescriptor + fd_Proof_account_proof protoreflect.FieldDescriptor + fd_Proof_storage_proof protoreflect.FieldDescriptor +) + +func init() { + file_tibc_lightclients_bsc_v1_bsc_proto_init() + md_Proof = File_tibc_lightclients_bsc_v1_bsc_proto.Messages().ByName("Proof") + fd_Proof_address = md_Proof.Fields().ByName("address") + fd_Proof_balance = md_Proof.Fields().ByName("balance") + fd_Proof_code_hash = md_Proof.Fields().ByName("code_hash") + fd_Proof_nonce = md_Proof.Fields().ByName("nonce") + fd_Proof_storage_hash = md_Proof.Fields().ByName("storage_hash") + fd_Proof_account_proof = md_Proof.Fields().ByName("account_proof") + fd_Proof_storage_proof = md_Proof.Fields().ByName("storage_proof") +} + +var _ protoreflect.Message = (*fastReflection_Proof)(nil) + +type fastReflection_Proof Proof + +func (x *Proof) ProtoReflect() protoreflect.Message { + return (*fastReflection_Proof)(x) +} + +func (x *Proof) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_lightclients_bsc_v1_bsc_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_Proof_messageType fastReflection_Proof_messageType +var _ protoreflect.MessageType = fastReflection_Proof_messageType{} + +type fastReflection_Proof_messageType struct{} + +func (x fastReflection_Proof_messageType) Zero() protoreflect.Message { + return (*fastReflection_Proof)(nil) +} +func (x fastReflection_Proof_messageType) New() protoreflect.Message { + return new(fastReflection_Proof) +} +func (x fastReflection_Proof_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Proof +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Proof) Descriptor() protoreflect.MessageDescriptor { + return md_Proof +} + +// 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_Proof) Type() protoreflect.MessageType { + return _fastReflection_Proof_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Proof) New() protoreflect.Message { + return new(fastReflection_Proof) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Proof) Interface() protoreflect.ProtoMessage { + return (*Proof)(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_Proof) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Address != "" { + value := protoreflect.ValueOfString(x.Address) + if !f(fd_Proof_address, value) { + return + } + } + if x.Balance != "" { + value := protoreflect.ValueOfString(x.Balance) + if !f(fd_Proof_balance, value) { + return + } + } + if x.CodeHash != "" { + value := protoreflect.ValueOfString(x.CodeHash) + if !f(fd_Proof_code_hash, value) { + return + } + } + if x.Nonce != "" { + value := protoreflect.ValueOfString(x.Nonce) + if !f(fd_Proof_nonce, value) { + return + } + } + if x.StorageHash != "" { + value := protoreflect.ValueOfString(x.StorageHash) + if !f(fd_Proof_storage_hash, value) { + return + } + } + if len(x.AccountProof) != 0 { + value := protoreflect.ValueOfList(&_Proof_6_list{list: &x.AccountProof}) + if !f(fd_Proof_account_proof, value) { + return + } + } + if len(x.StorageProof) != 0 { + value := protoreflect.ValueOfList(&_Proof_7_list{list: &x.StorageProof}) + if !f(fd_Proof_storage_proof, 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_Proof) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.Proof.address": + return x.Address != "" + case "tibc.lightclients.bsc.v1.Proof.balance": + return x.Balance != "" + case "tibc.lightclients.bsc.v1.Proof.code_hash": + return x.CodeHash != "" + case "tibc.lightclients.bsc.v1.Proof.nonce": + return x.Nonce != "" + case "tibc.lightclients.bsc.v1.Proof.storage_hash": + return x.StorageHash != "" + case "tibc.lightclients.bsc.v1.Proof.account_proof": + return len(x.AccountProof) != 0 + case "tibc.lightclients.bsc.v1.Proof.storage_proof": + return len(x.StorageProof) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.Proof")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.Proof 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_Proof) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.Proof.address": + x.Address = "" + case "tibc.lightclients.bsc.v1.Proof.balance": + x.Balance = "" + case "tibc.lightclients.bsc.v1.Proof.code_hash": + x.CodeHash = "" + case "tibc.lightclients.bsc.v1.Proof.nonce": + x.Nonce = "" + case "tibc.lightclients.bsc.v1.Proof.storage_hash": + x.StorageHash = "" + case "tibc.lightclients.bsc.v1.Proof.account_proof": + x.AccountProof = nil + case "tibc.lightclients.bsc.v1.Proof.storage_proof": + x.StorageProof = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.Proof")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.Proof 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_Proof) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.lightclients.bsc.v1.Proof.address": + value := x.Address + return protoreflect.ValueOfString(value) + case "tibc.lightclients.bsc.v1.Proof.balance": + value := x.Balance + return protoreflect.ValueOfString(value) + case "tibc.lightclients.bsc.v1.Proof.code_hash": + value := x.CodeHash + return protoreflect.ValueOfString(value) + case "tibc.lightclients.bsc.v1.Proof.nonce": + value := x.Nonce + return protoreflect.ValueOfString(value) + case "tibc.lightclients.bsc.v1.Proof.storage_hash": + value := x.StorageHash + return protoreflect.ValueOfString(value) + case "tibc.lightclients.bsc.v1.Proof.account_proof": + if len(x.AccountProof) == 0 { + return protoreflect.ValueOfList(&_Proof_6_list{}) + } + listValue := &_Proof_6_list{list: &x.AccountProof} + return protoreflect.ValueOfList(listValue) + case "tibc.lightclients.bsc.v1.Proof.storage_proof": + if len(x.StorageProof) == 0 { + return protoreflect.ValueOfList(&_Proof_7_list{}) + } + listValue := &_Proof_7_list{list: &x.StorageProof} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.Proof")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.Proof 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_Proof) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.Proof.address": + x.Address = value.Interface().(string) + case "tibc.lightclients.bsc.v1.Proof.balance": + x.Balance = value.Interface().(string) + case "tibc.lightclients.bsc.v1.Proof.code_hash": + x.CodeHash = value.Interface().(string) + case "tibc.lightclients.bsc.v1.Proof.nonce": + x.Nonce = value.Interface().(string) + case "tibc.lightclients.bsc.v1.Proof.storage_hash": + x.StorageHash = value.Interface().(string) + case "tibc.lightclients.bsc.v1.Proof.account_proof": + lv := value.List() + clv := lv.(*_Proof_6_list) + x.AccountProof = *clv.list + case "tibc.lightclients.bsc.v1.Proof.storage_proof": + lv := value.List() + clv := lv.(*_Proof_7_list) + x.StorageProof = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.Proof")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.Proof 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_Proof) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.Proof.account_proof": + if x.AccountProof == nil { + x.AccountProof = []string{} + } + value := &_Proof_6_list{list: &x.AccountProof} + return protoreflect.ValueOfList(value) + case "tibc.lightclients.bsc.v1.Proof.storage_proof": + if x.StorageProof == nil { + x.StorageProof = []*StorageResult{} + } + value := &_Proof_7_list{list: &x.StorageProof} + return protoreflect.ValueOfList(value) + case "tibc.lightclients.bsc.v1.Proof.address": + panic(fmt.Errorf("field address of message tibc.lightclients.bsc.v1.Proof is not mutable")) + case "tibc.lightclients.bsc.v1.Proof.balance": + panic(fmt.Errorf("field balance of message tibc.lightclients.bsc.v1.Proof is not mutable")) + case "tibc.lightclients.bsc.v1.Proof.code_hash": + panic(fmt.Errorf("field code_hash of message tibc.lightclients.bsc.v1.Proof is not mutable")) + case "tibc.lightclients.bsc.v1.Proof.nonce": + panic(fmt.Errorf("field nonce of message tibc.lightclients.bsc.v1.Proof is not mutable")) + case "tibc.lightclients.bsc.v1.Proof.storage_hash": + panic(fmt.Errorf("field storage_hash of message tibc.lightclients.bsc.v1.Proof is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.Proof")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.Proof 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_Proof) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.bsc.v1.Proof.address": + return protoreflect.ValueOfString("") + case "tibc.lightclients.bsc.v1.Proof.balance": + return protoreflect.ValueOfString("") + case "tibc.lightclients.bsc.v1.Proof.code_hash": + return protoreflect.ValueOfString("") + case "tibc.lightclients.bsc.v1.Proof.nonce": + return protoreflect.ValueOfString("") + case "tibc.lightclients.bsc.v1.Proof.storage_hash": + return protoreflect.ValueOfString("") + case "tibc.lightclients.bsc.v1.Proof.account_proof": + list := []string{} + return protoreflect.ValueOfList(&_Proof_6_list{list: &list}) + case "tibc.lightclients.bsc.v1.Proof.storage_proof": + list := []*StorageResult{} + return protoreflect.ValueOfList(&_Proof_7_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.bsc.v1.Proof")) + } + panic(fmt.Errorf("message tibc.lightclients.bsc.v1.Proof 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_Proof) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.lightclients.bsc.v1.Proof", 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_Proof) 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_Proof) 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_Proof) 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_Proof) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Proof) + 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.Address) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Balance) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.CodeHash) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Nonce) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.StorageHash) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.AccountProof) > 0 { + for _, s := range x.AccountProof { + l = len(s) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if len(x.StorageProof) > 0 { + for _, e := range x.StorageProof { + 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().(*Proof) + 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.StorageProof) > 0 { + for iNdEx := len(x.StorageProof) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.StorageProof[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] = 0x3a + } + } + if len(x.AccountProof) > 0 { + for iNdEx := len(x.AccountProof) - 1; iNdEx >= 0; iNdEx-- { + i -= len(x.AccountProof[iNdEx]) + copy(dAtA[i:], x.AccountProof[iNdEx]) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.AccountProof[iNdEx]))) + i-- + dAtA[i] = 0x32 + } + } + if len(x.StorageHash) > 0 { + i -= len(x.StorageHash) + copy(dAtA[i:], x.StorageHash) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.StorageHash))) + i-- + dAtA[i] = 0x2a + } + if len(x.Nonce) > 0 { + i -= len(x.Nonce) + copy(dAtA[i:], x.Nonce) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Nonce))) + i-- + dAtA[i] = 0x22 + } + if len(x.CodeHash) > 0 { + i -= len(x.CodeHash) + copy(dAtA[i:], x.CodeHash) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.CodeHash))) + i-- + dAtA[i] = 0x1a + } + if len(x.Balance) > 0 { + i -= len(x.Balance) + copy(dAtA[i:], x.Balance) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Balance))) + i-- + dAtA[i] = 0x12 + } + if len(x.Address) > 0 { + i -= len(x.Address) + copy(dAtA[i:], x.Address) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Address))) + 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().(*Proof) + 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: Proof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Proof: 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 Address", 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.Address = 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 Balance", 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.Balance = 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 CodeHash", 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.CodeHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nonce", 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.Nonce = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StorageHash", 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.StorageHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field AccountProof", 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.AccountProof = append(x.AccountProof, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StorageProof", 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.StorageProof = append(x.StorageProof, &StorageResult{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.StorageProof[len(x.StorageProof)-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: tibc/lightclients/bsc/v1/bsc.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) +) + +// Header defines the bsc client consensus Header. +type Header struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ParentHash []byte `protobuf:"bytes,1,opt,name=parent_hash,json=parentHash,proto3" json:"parent_hash,omitempty"` + UncleHash []byte `protobuf:"bytes,2,opt,name=uncle_hash,json=uncleHash,proto3" json:"uncle_hash,omitempty"` + Coinbase []byte `protobuf:"bytes,3,opt,name=coinbase,proto3" json:"coinbase,omitempty"` + Root []byte `protobuf:"bytes,4,opt,name=root,proto3" json:"root,omitempty"` + TxHash []byte `protobuf:"bytes,5,opt,name=tx_hash,json=txHash,proto3" json:"tx_hash,omitempty"` + ReceiptHash []byte `protobuf:"bytes,6,opt,name=receipt_hash,json=receiptHash,proto3" json:"receipt_hash,omitempty"` + Bloom []byte `protobuf:"bytes,7,opt,name=bloom,proto3" json:"bloom,omitempty"` + Difficulty uint64 `protobuf:"varint,8,opt,name=difficulty,proto3" json:"difficulty,omitempty"` + Height *v1.Height `protobuf:"bytes,9,opt,name=height,proto3" json:"height,omitempty"` + GasLimit uint64 `protobuf:"varint,10,opt,name=gas_limit,json=gasLimit,proto3" json:"gas_limit,omitempty"` + GasUsed uint64 `protobuf:"varint,11,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"` + Time uint64 `protobuf:"varint,12,opt,name=time,proto3" json:"time,omitempty"` + Extra []byte `protobuf:"bytes,13,opt,name=extra,proto3" json:"extra,omitempty"` + MixDigest []byte `protobuf:"bytes,14,opt,name=mix_digest,json=mixDigest,proto3" json:"mix_digest,omitempty"` + Nonce []byte `protobuf:"bytes,15,opt,name=nonce,proto3" json:"nonce,omitempty"` +} + +func (x *Header) Reset() { + *x = Header{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_lightclients_bsc_v1_bsc_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Header) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Header) ProtoMessage() {} + +// Deprecated: Use Header.ProtoReflect.Descriptor instead. +func (*Header) Descriptor() ([]byte, []int) { + return file_tibc_lightclients_bsc_v1_bsc_proto_rawDescGZIP(), []int{0} +} + +func (x *Header) GetParentHash() []byte { + if x != nil { + return x.ParentHash + } + return nil +} + +func (x *Header) GetUncleHash() []byte { + if x != nil { + return x.UncleHash + } + return nil +} + +func (x *Header) GetCoinbase() []byte { + if x != nil { + return x.Coinbase + } + return nil +} + +func (x *Header) GetRoot() []byte { + if x != nil { + return x.Root + } + return nil +} + +func (x *Header) GetTxHash() []byte { + if x != nil { + return x.TxHash + } + return nil +} + +func (x *Header) GetReceiptHash() []byte { + if x != nil { + return x.ReceiptHash + } + return nil +} + +func (x *Header) GetBloom() []byte { + if x != nil { + return x.Bloom + } + return nil +} + +func (x *Header) GetDifficulty() uint64 { + if x != nil { + return x.Difficulty + } + return 0 +} + +func (x *Header) GetHeight() *v1.Height { + if x != nil { + return x.Height + } + return nil +} + +func (x *Header) GetGasLimit() uint64 { + if x != nil { + return x.GasLimit + } + return 0 +} + +func (x *Header) GetGasUsed() uint64 { + if x != nil { + return x.GasUsed + } + return 0 +} + +func (x *Header) GetTime() uint64 { + if x != nil { + return x.Time + } + return 0 +} + +func (x *Header) GetExtra() []byte { + if x != nil { + return x.Extra + } + return nil +} + +func (x *Header) GetMixDigest() []byte { + if x != nil { + return x.MixDigest + } + return nil +} + +func (x *Header) GetNonce() []byte { + if x != nil { + return x.Nonce + } + return nil +} + +// ClientState from bsc tracks the current validator set, latest height, +// and a possible frozen height. +type ClientState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Header *Header `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + ChainId uint64 `protobuf:"varint,2,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + Epoch uint64 `protobuf:"varint,3,opt,name=epoch,proto3" json:"epoch,omitempty"` + BlockInteval uint64 `protobuf:"varint,4,opt,name=block_inteval,json=blockInteval,proto3" json:"block_inteval,omitempty"` + Validators [][]byte `protobuf:"bytes,5,rep,name=validators,proto3" json:"validators,omitempty"` + RecentSigners []*Signer `protobuf:"bytes,6,rep,name=recent_signers,json=recentSigners,proto3" json:"recent_signers,omitempty"` + ContractAddress []byte `protobuf:"bytes,7,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"` + TrustingPeriod uint64 `protobuf:"varint,8,opt,name=trusting_period,json=trustingPeriod,proto3" json:"trusting_period,omitempty"` +} + +func (x *ClientState) Reset() { + *x = ClientState{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_lightclients_bsc_v1_bsc_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ClientState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ClientState) ProtoMessage() {} + +// Deprecated: Use ClientState.ProtoReflect.Descriptor instead. +func (*ClientState) Descriptor() ([]byte, []int) { + return file_tibc_lightclients_bsc_v1_bsc_proto_rawDescGZIP(), []int{1} +} + +func (x *ClientState) GetHeader() *Header { + if x != nil { + return x.Header + } + return nil +} + +func (x *ClientState) GetChainId() uint64 { + if x != nil { + return x.ChainId + } + return 0 +} + +func (x *ClientState) GetEpoch() uint64 { + if x != nil { + return x.Epoch + } + return 0 +} + +func (x *ClientState) GetBlockInteval() uint64 { + if x != nil { + return x.BlockInteval + } + return 0 +} + +func (x *ClientState) GetValidators() [][]byte { + if x != nil { + return x.Validators + } + return nil +} + +func (x *ClientState) GetRecentSigners() []*Signer { + if x != nil { + return x.RecentSigners + } + return nil +} + +func (x *ClientState) GetContractAddress() []byte { + if x != nil { + return x.ContractAddress + } + return nil +} + +func (x *ClientState) GetTrustingPeriod() uint64 { + if x != nil { + return x.TrustingPeriod + } + return 0 +} + +type Signer struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Height *v1.Height `protobuf:"bytes,1,opt,name=height,proto3" json:"height,omitempty"` + Validator []byte `protobuf:"bytes,2,opt,name=validator,proto3" json:"validator,omitempty"` +} + +func (x *Signer) Reset() { + *x = Signer{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_lightclients_bsc_v1_bsc_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Signer) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Signer) ProtoMessage() {} + +// Deprecated: Use Signer.ProtoReflect.Descriptor instead. +func (*Signer) Descriptor() ([]byte, []int) { + return file_tibc_lightclients_bsc_v1_bsc_proto_rawDescGZIP(), []int{2} +} + +func (x *Signer) GetHeight() *v1.Height { + if x != nil { + return x.Height + } + return nil +} + +func (x *Signer) GetValidator() []byte { + if x != nil { + return x.Validator + } + return nil +} + +type SignerSet struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Signers []*Signer `protobuf:"bytes,1,rep,name=signers,proto3" json:"signers,omitempty"` +} + +func (x *SignerSet) Reset() { + *x = SignerSet{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_lightclients_bsc_v1_bsc_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SignerSet) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SignerSet) ProtoMessage() {} + +// Deprecated: Use SignerSet.ProtoReflect.Descriptor instead. +func (*SignerSet) Descriptor() ([]byte, []int) { + return file_tibc_lightclients_bsc_v1_bsc_proto_rawDescGZIP(), []int{3} +} + +func (x *SignerSet) GetSigners() []*Signer { + if x != nil { + return x.Signers + } + return nil +} + +type ValidatorSet struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Validators [][]byte `protobuf:"bytes,1,rep,name=validators,proto3" json:"validators,omitempty"` +} + +func (x *ValidatorSet) Reset() { + *x = ValidatorSet{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_lightclients_bsc_v1_bsc_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ValidatorSet) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ValidatorSet) ProtoMessage() {} + +// Deprecated: Use ValidatorSet.ProtoReflect.Descriptor instead. +func (*ValidatorSet) Descriptor() ([]byte, []int) { + return file_tibc_lightclients_bsc_v1_bsc_proto_rawDescGZIP(), []int{4} +} + +func (x *ValidatorSet) GetValidators() [][]byte { + if x != nil { + return x.Validators + } + return nil +} + +// ConsensusState defines the consensus state from bsc. +type ConsensusState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // timestamp that corresponds to the block height in which the ConsensusState + // was stored. + Timestamp uint64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + Number *v1.Height `protobuf:"bytes,2,opt,name=number,proto3" json:"number,omitempty"` + Root []byte `protobuf:"bytes,3,opt,name=root,proto3" json:"root,omitempty"` +} + +func (x *ConsensusState) Reset() { + *x = ConsensusState{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_lightclients_bsc_v1_bsc_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ConsensusState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ConsensusState) ProtoMessage() {} + +// Deprecated: Use ConsensusState.ProtoReflect.Descriptor instead. +func (*ConsensusState) Descriptor() ([]byte, []int) { + return file_tibc_lightclients_bsc_v1_bsc_proto_rawDescGZIP(), []int{5} +} + +func (x *ConsensusState) GetTimestamp() uint64 { + if x != nil { + return x.Timestamp + } + return 0 +} + +func (x *ConsensusState) GetNumber() *v1.Height { + if x != nil { + return x.Number + } + return nil +} + +func (x *ConsensusState) GetRoot() []byte { + if x != nil { + return x.Root + } + return nil +} + +type StorageResult struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + Proof []string `protobuf:"bytes,3,rep,name=proof,proto3" json:"proof,omitempty"` +} + +func (x *StorageResult) Reset() { + *x = StorageResult{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_lightclients_bsc_v1_bsc_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *StorageResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StorageResult) ProtoMessage() {} + +// Deprecated: Use StorageResult.ProtoReflect.Descriptor instead. +func (*StorageResult) Descriptor() ([]byte, []int) { + return file_tibc_lightclients_bsc_v1_bsc_proto_rawDescGZIP(), []int{6} +} + +func (x *StorageResult) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *StorageResult) GetValue() string { + if x != nil { + return x.Value + } + return "" +} + +func (x *StorageResult) GetProof() []string { + if x != nil { + return x.Proof + } + return nil +} + +type Proof struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + Balance string `protobuf:"bytes,2,opt,name=balance,proto3" json:"balance,omitempty"` + CodeHash string `protobuf:"bytes,3,opt,name=code_hash,json=codeHash,proto3" json:"code_hash,omitempty"` + Nonce string `protobuf:"bytes,4,opt,name=nonce,proto3" json:"nonce,omitempty"` + StorageHash string `protobuf:"bytes,5,opt,name=storage_hash,json=storageHash,proto3" json:"storage_hash,omitempty"` + AccountProof []string `protobuf:"bytes,6,rep,name=account_proof,json=accountProof,proto3" json:"account_proof,omitempty"` + StorageProof []*StorageResult `protobuf:"bytes,7,rep,name=storage_proof,json=storageProof,proto3" json:"storage_proof,omitempty"` +} + +func (x *Proof) Reset() { + *x = Proof{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_lightclients_bsc_v1_bsc_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Proof) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Proof) ProtoMessage() {} + +// Deprecated: Use Proof.ProtoReflect.Descriptor instead. +func (*Proof) Descriptor() ([]byte, []int) { + return file_tibc_lightclients_bsc_v1_bsc_proto_rawDescGZIP(), []int{7} +} + +func (x *Proof) GetAddress() string { + if x != nil { + return x.Address + } + return "" +} + +func (x *Proof) GetBalance() string { + if x != nil { + return x.Balance + } + return "" +} + +func (x *Proof) GetCodeHash() string { + if x != nil { + return x.CodeHash + } + return "" +} + +func (x *Proof) GetNonce() string { + if x != nil { + return x.Nonce + } + return "" +} + +func (x *Proof) GetStorageHash() string { + if x != nil { + return x.StorageHash + } + return "" +} + +func (x *Proof) GetAccountProof() []string { + if x != nil { + return x.AccountProof + } + return nil +} + +func (x *Proof) GetStorageProof() []*StorageResult { + if x != nil { + return x.StorageProof + } + return nil +} + +var File_tibc_lightclients_bsc_v1_bsc_proto protoreflect.FileDescriptor + +var file_tibc_lightclients_bsc_v1_bsc_proto_rawDesc = []byte{ + 0x0a, 0x22, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x73, 0x2f, 0x62, 0x73, 0x63, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x73, 0x63, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x18, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x6c, 0x69, 0x67, 0x68, 0x74, + 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x62, 0x73, 0x63, 0x2e, 0x76, 0x31, 0x1a, 0x14, + 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, + 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc2, 0x03, 0x0a, 0x06, 0x48, 0x65, 0x61, 0x64, 0x65, + 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, + 0x73, 0x68, 0x12, 0x1d, 0x0a, 0x0a, 0x75, 0x6e, 0x63, 0x6c, 0x65, 0x5f, 0x68, 0x61, 0x73, 0x68, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x75, 0x6e, 0x63, 0x6c, 0x65, 0x48, 0x61, 0x73, + 0x68, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x6f, 0x69, 0x6e, 0x62, 0x61, 0x73, 0x65, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x08, 0x63, 0x6f, 0x69, 0x6e, 0x62, 0x61, 0x73, 0x65, 0x12, 0x12, 0x0a, + 0x04, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x72, 0x6f, 0x6f, + 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x78, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x0c, 0x52, 0x06, 0x74, 0x78, 0x48, 0x61, 0x73, 0x68, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x65, + 0x63, 0x65, 0x69, 0x70, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x0b, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x14, 0x0a, + 0x05, 0x62, 0x6c, 0x6f, 0x6f, 0x6d, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x62, 0x6c, + 0x6f, 0x6f, 0x6d, 0x12, 0x1e, 0x0a, 0x0a, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, + 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, + 0x6c, 0x74, 0x79, 0x12, 0x39, 0x0a, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x09, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, + 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1b, + 0x0a, 0x09, 0x67, 0x61, 0x73, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, + 0x04, 0x52, 0x08, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x67, + 0x61, 0x73, 0x5f, 0x75, 0x73, 0x65, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x67, + 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0c, + 0x20, 0x01, 0x28, 0x04, 0x52, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x78, + 0x74, 0x72, 0x61, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x65, 0x78, 0x74, 0x72, 0x61, + 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x69, 0x78, 0x5f, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x18, 0x0e, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x6d, 0x69, 0x78, 0x44, 0x69, 0x67, 0x65, 0x73, 0x74, 0x12, + 0x14, 0x0a, 0x05, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, + 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x3a, 0x04, 0x88, 0xa0, 0x1f, 0x00, 0x22, 0xec, 0x02, 0x0a, 0x0b, + 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x3e, 0x0a, 0x06, 0x68, + 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x74, 0x69, + 0x62, 0x63, 0x2e, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x2e, + 0x62, 0x73, 0x63, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x42, 0x04, 0xc8, + 0xde, 0x1f, 0x00, 0x52, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x19, 0x0a, 0x08, 0x63, + 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x63, + 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x23, 0x0a, 0x0d, + 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x76, 0x61, 0x6c, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x04, 0x52, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x49, 0x6e, 0x74, 0x65, 0x76, 0x61, + 0x6c, 0x12, 0x1e, 0x0a, 0x0a, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x18, + 0x05, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0a, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, + 0x73, 0x12, 0x4d, 0x0a, 0x0e, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x69, 0x67, 0x6e, + 0x65, 0x72, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x74, 0x69, 0x62, 0x63, + 0x2e, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x62, 0x73, + 0x63, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x42, 0x04, 0xc8, 0xde, 0x1f, + 0x00, 0x52, 0x0d, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x73, + 0x12, 0x29, 0x0a, 0x10, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x5f, 0x61, 0x64, 0x64, + 0x72, 0x65, 0x73, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x63, 0x6f, 0x6e, 0x74, + 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x74, + 0x72, 0x75, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x74, 0x72, 0x75, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x65, + 0x72, 0x69, 0x6f, 0x64, 0x3a, 0x04, 0x88, 0xa0, 0x1f, 0x00, 0x22, 0x61, 0x0a, 0x06, 0x53, 0x69, + 0x67, 0x6e, 0x65, 0x72, 0x12, 0x39, 0x0a, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x65, 0x69, 0x67, 0x68, + 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, + 0x1c, 0x0a, 0x09, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0c, 0x52, 0x09, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x4d, 0x0a, + 0x09, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x53, 0x65, 0x74, 0x12, 0x40, 0x0a, 0x07, 0x73, 0x69, + 0x67, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x74, 0x69, + 0x62, 0x63, 0x2e, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x2e, + 0x62, 0x73, 0x63, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x42, 0x04, 0xc8, + 0xde, 0x1f, 0x00, 0x52, 0x07, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x73, 0x22, 0x2e, 0x0a, 0x0c, + 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x65, 0x74, 0x12, 0x1e, 0x0a, 0x0a, + 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0c, + 0x52, 0x0a, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x22, 0x83, 0x01, 0x0a, + 0x0e, 0x43, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, + 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x04, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x39, 0x0a, + 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, + 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, + 0x52, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x6f, 0x6f, 0x74, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x72, 0x6f, 0x6f, 0x74, 0x3a, 0x04, 0x88, 0xa0, + 0x1f, 0x00, 0x22, 0x53, 0x0a, 0x0d, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, + 0x75, 0x6c, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x70, + 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x70, 0x72, 0x6f, 0x6f, + 0x66, 0x3a, 0x04, 0x88, 0xa0, 0x1f, 0x00, 0x22, 0x8a, 0x02, 0x0a, 0x05, 0x50, 0x72, 0x6f, 0x6f, + 0x66, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x62, + 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x62, 0x61, + 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x68, 0x61, + 0x73, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x6f, 0x64, 0x65, 0x48, 0x61, + 0x73, 0x68, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x74, 0x6f, 0x72, + 0x61, 0x67, 0x65, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, + 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x48, 0x61, 0x73, 0x68, 0x12, 0x23, 0x0a, 0x0d, 0x61, + 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x06, 0x20, 0x03, + 0x28, 0x09, 0x52, 0x0c, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, + 0x12, 0x4c, 0x0a, 0x0d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x6f, + 0x66, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x6c, + 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x62, 0x73, 0x63, 0x2e, + 0x76, 0x31, 0x2e, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x52, 0x0c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x3a, 0x04, + 0x88, 0xa0, 0x1f, 0x00, 0x42, 0xec, 0x01, 0x0a, 0x1c, 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, + 0x63, 0x2e, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x62, + 0x73, 0x63, 0x2e, 0x76, 0x31, 0x42, 0x08, 0x42, 0x73, 0x63, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, + 0x01, 0x5a, 0x3f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x62, 0x69, + 0x61, 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2d, 0x67, 0x6f, 0x2f, + 0x61, 0x70, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x62, 0x73, 0x63, 0x2f, 0x76, 0x31, 0x3b, 0x62, 0x73, 0x63, + 0x76, 0x31, 0xa2, 0x02, 0x03, 0x54, 0x4c, 0x42, 0xaa, 0x02, 0x18, 0x54, 0x69, 0x62, 0x63, 0x2e, + 0x4c, 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x42, 0x73, 0x63, + 0x2e, 0x56, 0x31, 0xca, 0x02, 0x18, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x4c, 0x69, 0x67, 0x68, 0x74, + 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x5c, 0x42, 0x73, 0x63, 0x5c, 0x56, 0x31, 0xe2, 0x02, + 0x24, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, 0x6e, + 0x74, 0x73, 0x5c, 0x42, 0x73, 0x63, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x1b, 0x54, 0x69, 0x62, 0x63, 0x3a, 0x3a, 0x4c, 0x69, + 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x3a, 0x3a, 0x42, 0x73, 0x63, 0x3a, + 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_lightclients_bsc_v1_bsc_proto_rawDescOnce sync.Once + file_tibc_lightclients_bsc_v1_bsc_proto_rawDescData = file_tibc_lightclients_bsc_v1_bsc_proto_rawDesc +) + +func file_tibc_lightclients_bsc_v1_bsc_proto_rawDescGZIP() []byte { + file_tibc_lightclients_bsc_v1_bsc_proto_rawDescOnce.Do(func() { + file_tibc_lightclients_bsc_v1_bsc_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_lightclients_bsc_v1_bsc_proto_rawDescData) + }) + return file_tibc_lightclients_bsc_v1_bsc_proto_rawDescData +} + +var file_tibc_lightclients_bsc_v1_bsc_proto_msgTypes = make([]protoimpl.MessageInfo, 8) +var file_tibc_lightclients_bsc_v1_bsc_proto_goTypes = []interface{}{ + (*Header)(nil), // 0: tibc.lightclients.bsc.v1.Header + (*ClientState)(nil), // 1: tibc.lightclients.bsc.v1.ClientState + (*Signer)(nil), // 2: tibc.lightclients.bsc.v1.Signer + (*SignerSet)(nil), // 3: tibc.lightclients.bsc.v1.SignerSet + (*ValidatorSet)(nil), // 4: tibc.lightclients.bsc.v1.ValidatorSet + (*ConsensusState)(nil), // 5: tibc.lightclients.bsc.v1.ConsensusState + (*StorageResult)(nil), // 6: tibc.lightclients.bsc.v1.StorageResult + (*Proof)(nil), // 7: tibc.lightclients.bsc.v1.Proof + (*v1.Height)(nil), // 8: tibc.core.client.v1.Height +} +var file_tibc_lightclients_bsc_v1_bsc_proto_depIdxs = []int32{ + 8, // 0: tibc.lightclients.bsc.v1.Header.height:type_name -> tibc.core.client.v1.Height + 0, // 1: tibc.lightclients.bsc.v1.ClientState.header:type_name -> tibc.lightclients.bsc.v1.Header + 2, // 2: tibc.lightclients.bsc.v1.ClientState.recent_signers:type_name -> tibc.lightclients.bsc.v1.Signer + 8, // 3: tibc.lightclients.bsc.v1.Signer.height:type_name -> tibc.core.client.v1.Height + 2, // 4: tibc.lightclients.bsc.v1.SignerSet.signers:type_name -> tibc.lightclients.bsc.v1.Signer + 8, // 5: tibc.lightclients.bsc.v1.ConsensusState.number:type_name -> tibc.core.client.v1.Height + 6, // 6: tibc.lightclients.bsc.v1.Proof.storage_proof:type_name -> tibc.lightclients.bsc.v1.StorageResult + 7, // [7:7] is the sub-list for method output_type + 7, // [7:7] is the sub-list for method input_type + 7, // [7:7] is the sub-list for extension type_name + 7, // [7:7] is the sub-list for extension extendee + 0, // [0:7] is the sub-list for field type_name +} + +func init() { file_tibc_lightclients_bsc_v1_bsc_proto_init() } +func file_tibc_lightclients_bsc_v1_bsc_proto_init() { + if File_tibc_lightclients_bsc_v1_bsc_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_tibc_lightclients_bsc_v1_bsc_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Header); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_lightclients_bsc_v1_bsc_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ClientState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_lightclients_bsc_v1_bsc_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Signer); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_lightclients_bsc_v1_bsc_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SignerSet); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_lightclients_bsc_v1_bsc_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ValidatorSet); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_lightclients_bsc_v1_bsc_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ConsensusState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_lightclients_bsc_v1_bsc_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*StorageResult); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_lightclients_bsc_v1_bsc_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Proof); 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_tibc_lightclients_bsc_v1_bsc_proto_rawDesc, + NumEnums: 0, + NumMessages: 8, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_tibc_lightclients_bsc_v1_bsc_proto_goTypes, + DependencyIndexes: file_tibc_lightclients_bsc_v1_bsc_proto_depIdxs, + MessageInfos: file_tibc_lightclients_bsc_v1_bsc_proto_msgTypes, + }.Build() + File_tibc_lightclients_bsc_v1_bsc_proto = out.File + file_tibc_lightclients_bsc_v1_bsc_proto_rawDesc = nil + file_tibc_lightclients_bsc_v1_bsc_proto_goTypes = nil + file_tibc_lightclients_bsc_v1_bsc_proto_depIdxs = nil +} diff --git a/api/tibc/lightclients/eth/v1/eth.pulsar.go b/api/tibc/lightclients/eth/v1/eth.pulsar.go new file mode 100644 index 00000000..388da1b7 --- /dev/null +++ b/api/tibc/lightclients/eth/v1/eth.pulsar.go @@ -0,0 +1,4813 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package ethv1 + +import ( + fmt "fmt" + v1 "github.com/bianjieai/tibc-go/api/tibc/core/client/v1" + 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" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_Header protoreflect.MessageDescriptor + fd_Header_parent_hash protoreflect.FieldDescriptor + fd_Header_uncle_hash protoreflect.FieldDescriptor + fd_Header_coinbase protoreflect.FieldDescriptor + fd_Header_root protoreflect.FieldDescriptor + fd_Header_tx_hash protoreflect.FieldDescriptor + fd_Header_receipt_hash protoreflect.FieldDescriptor + fd_Header_bloom protoreflect.FieldDescriptor + fd_Header_difficulty protoreflect.FieldDescriptor + fd_Header_height protoreflect.FieldDescriptor + fd_Header_gas_limit protoreflect.FieldDescriptor + fd_Header_gas_used protoreflect.FieldDescriptor + fd_Header_time protoreflect.FieldDescriptor + fd_Header_extra protoreflect.FieldDescriptor + fd_Header_mix_digest protoreflect.FieldDescriptor + fd_Header_nonce protoreflect.FieldDescriptor + fd_Header_baseFee protoreflect.FieldDescriptor +) + +func init() { + file_tibc_lightclients_eth_v1_eth_proto_init() + md_Header = File_tibc_lightclients_eth_v1_eth_proto.Messages().ByName("Header") + fd_Header_parent_hash = md_Header.Fields().ByName("parent_hash") + fd_Header_uncle_hash = md_Header.Fields().ByName("uncle_hash") + fd_Header_coinbase = md_Header.Fields().ByName("coinbase") + fd_Header_root = md_Header.Fields().ByName("root") + fd_Header_tx_hash = md_Header.Fields().ByName("tx_hash") + fd_Header_receipt_hash = md_Header.Fields().ByName("receipt_hash") + fd_Header_bloom = md_Header.Fields().ByName("bloom") + fd_Header_difficulty = md_Header.Fields().ByName("difficulty") + fd_Header_height = md_Header.Fields().ByName("height") + fd_Header_gas_limit = md_Header.Fields().ByName("gas_limit") + fd_Header_gas_used = md_Header.Fields().ByName("gas_used") + fd_Header_time = md_Header.Fields().ByName("time") + fd_Header_extra = md_Header.Fields().ByName("extra") + fd_Header_mix_digest = md_Header.Fields().ByName("mix_digest") + fd_Header_nonce = md_Header.Fields().ByName("nonce") + fd_Header_baseFee = md_Header.Fields().ByName("baseFee") +} + +var _ protoreflect.Message = (*fastReflection_Header)(nil) + +type fastReflection_Header Header + +func (x *Header) ProtoReflect() protoreflect.Message { + return (*fastReflection_Header)(x) +} + +func (x *Header) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_lightclients_eth_v1_eth_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_Header_messageType fastReflection_Header_messageType +var _ protoreflect.MessageType = fastReflection_Header_messageType{} + +type fastReflection_Header_messageType struct{} + +func (x fastReflection_Header_messageType) Zero() protoreflect.Message { + return (*fastReflection_Header)(nil) +} +func (x fastReflection_Header_messageType) New() protoreflect.Message { + return new(fastReflection_Header) +} +func (x fastReflection_Header_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Header +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Header) Descriptor() protoreflect.MessageDescriptor { + return md_Header +} + +// 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_Header) Type() protoreflect.MessageType { + return _fastReflection_Header_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Header) New() protoreflect.Message { + return new(fastReflection_Header) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Header) Interface() protoreflect.ProtoMessage { + return (*Header)(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_Header) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.ParentHash) != 0 { + value := protoreflect.ValueOfBytes(x.ParentHash) + if !f(fd_Header_parent_hash, value) { + return + } + } + if len(x.UncleHash) != 0 { + value := protoreflect.ValueOfBytes(x.UncleHash) + if !f(fd_Header_uncle_hash, value) { + return + } + } + if len(x.Coinbase) != 0 { + value := protoreflect.ValueOfBytes(x.Coinbase) + if !f(fd_Header_coinbase, value) { + return + } + } + if len(x.Root) != 0 { + value := protoreflect.ValueOfBytes(x.Root) + if !f(fd_Header_root, value) { + return + } + } + if len(x.TxHash) != 0 { + value := protoreflect.ValueOfBytes(x.TxHash) + if !f(fd_Header_tx_hash, value) { + return + } + } + if len(x.ReceiptHash) != 0 { + value := protoreflect.ValueOfBytes(x.ReceiptHash) + if !f(fd_Header_receipt_hash, value) { + return + } + } + if len(x.Bloom) != 0 { + value := protoreflect.ValueOfBytes(x.Bloom) + if !f(fd_Header_bloom, value) { + return + } + } + if x.Difficulty != "" { + value := protoreflect.ValueOfString(x.Difficulty) + if !f(fd_Header_difficulty, value) { + return + } + } + if x.Height != nil { + value := protoreflect.ValueOfMessage(x.Height.ProtoReflect()) + if !f(fd_Header_height, value) { + return + } + } + if x.GasLimit != uint64(0) { + value := protoreflect.ValueOfUint64(x.GasLimit) + if !f(fd_Header_gas_limit, value) { + return + } + } + if x.GasUsed != uint64(0) { + value := protoreflect.ValueOfUint64(x.GasUsed) + if !f(fd_Header_gas_used, value) { + return + } + } + if x.Time != uint64(0) { + value := protoreflect.ValueOfUint64(x.Time) + if !f(fd_Header_time, value) { + return + } + } + if len(x.Extra) != 0 { + value := protoreflect.ValueOfBytes(x.Extra) + if !f(fd_Header_extra, value) { + return + } + } + if len(x.MixDigest) != 0 { + value := protoreflect.ValueOfBytes(x.MixDigest) + if !f(fd_Header_mix_digest, value) { + return + } + } + if x.Nonce != uint64(0) { + value := protoreflect.ValueOfUint64(x.Nonce) + if !f(fd_Header_nonce, value) { + return + } + } + if x.BaseFee != "" { + value := protoreflect.ValueOfString(x.BaseFee) + if !f(fd_Header_baseFee, 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_Header) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.Header.parent_hash": + return len(x.ParentHash) != 0 + case "tibc.lightclients.eth.v1.Header.uncle_hash": + return len(x.UncleHash) != 0 + case "tibc.lightclients.eth.v1.Header.coinbase": + return len(x.Coinbase) != 0 + case "tibc.lightclients.eth.v1.Header.root": + return len(x.Root) != 0 + case "tibc.lightclients.eth.v1.Header.tx_hash": + return len(x.TxHash) != 0 + case "tibc.lightclients.eth.v1.Header.receipt_hash": + return len(x.ReceiptHash) != 0 + case "tibc.lightclients.eth.v1.Header.bloom": + return len(x.Bloom) != 0 + case "tibc.lightclients.eth.v1.Header.difficulty": + return x.Difficulty != "" + case "tibc.lightclients.eth.v1.Header.height": + return x.Height != nil + case "tibc.lightclients.eth.v1.Header.gas_limit": + return x.GasLimit != uint64(0) + case "tibc.lightclients.eth.v1.Header.gas_used": + return x.GasUsed != uint64(0) + case "tibc.lightclients.eth.v1.Header.time": + return x.Time != uint64(0) + case "tibc.lightclients.eth.v1.Header.extra": + return len(x.Extra) != 0 + case "tibc.lightclients.eth.v1.Header.mix_digest": + return len(x.MixDigest) != 0 + case "tibc.lightclients.eth.v1.Header.nonce": + return x.Nonce != uint64(0) + case "tibc.lightclients.eth.v1.Header.baseFee": + return x.BaseFee != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.Header")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.Header 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_Header) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.Header.parent_hash": + x.ParentHash = nil + case "tibc.lightclients.eth.v1.Header.uncle_hash": + x.UncleHash = nil + case "tibc.lightclients.eth.v1.Header.coinbase": + x.Coinbase = nil + case "tibc.lightclients.eth.v1.Header.root": + x.Root = nil + case "tibc.lightclients.eth.v1.Header.tx_hash": + x.TxHash = nil + case "tibc.lightclients.eth.v1.Header.receipt_hash": + x.ReceiptHash = nil + case "tibc.lightclients.eth.v1.Header.bloom": + x.Bloom = nil + case "tibc.lightclients.eth.v1.Header.difficulty": + x.Difficulty = "" + case "tibc.lightclients.eth.v1.Header.height": + x.Height = nil + case "tibc.lightclients.eth.v1.Header.gas_limit": + x.GasLimit = uint64(0) + case "tibc.lightclients.eth.v1.Header.gas_used": + x.GasUsed = uint64(0) + case "tibc.lightclients.eth.v1.Header.time": + x.Time = uint64(0) + case "tibc.lightclients.eth.v1.Header.extra": + x.Extra = nil + case "tibc.lightclients.eth.v1.Header.mix_digest": + x.MixDigest = nil + case "tibc.lightclients.eth.v1.Header.nonce": + x.Nonce = uint64(0) + case "tibc.lightclients.eth.v1.Header.baseFee": + x.BaseFee = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.Header")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.Header 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_Header) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.lightclients.eth.v1.Header.parent_hash": + value := x.ParentHash + return protoreflect.ValueOfBytes(value) + case "tibc.lightclients.eth.v1.Header.uncle_hash": + value := x.UncleHash + return protoreflect.ValueOfBytes(value) + case "tibc.lightclients.eth.v1.Header.coinbase": + value := x.Coinbase + return protoreflect.ValueOfBytes(value) + case "tibc.lightclients.eth.v1.Header.root": + value := x.Root + return protoreflect.ValueOfBytes(value) + case "tibc.lightclients.eth.v1.Header.tx_hash": + value := x.TxHash + return protoreflect.ValueOfBytes(value) + case "tibc.lightclients.eth.v1.Header.receipt_hash": + value := x.ReceiptHash + return protoreflect.ValueOfBytes(value) + case "tibc.lightclients.eth.v1.Header.bloom": + value := x.Bloom + return protoreflect.ValueOfBytes(value) + case "tibc.lightclients.eth.v1.Header.difficulty": + value := x.Difficulty + return protoreflect.ValueOfString(value) + case "tibc.lightclients.eth.v1.Header.height": + value := x.Height + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.lightclients.eth.v1.Header.gas_limit": + value := x.GasLimit + return protoreflect.ValueOfUint64(value) + case "tibc.lightclients.eth.v1.Header.gas_used": + value := x.GasUsed + return protoreflect.ValueOfUint64(value) + case "tibc.lightclients.eth.v1.Header.time": + value := x.Time + return protoreflect.ValueOfUint64(value) + case "tibc.lightclients.eth.v1.Header.extra": + value := x.Extra + return protoreflect.ValueOfBytes(value) + case "tibc.lightclients.eth.v1.Header.mix_digest": + value := x.MixDigest + return protoreflect.ValueOfBytes(value) + case "tibc.lightclients.eth.v1.Header.nonce": + value := x.Nonce + return protoreflect.ValueOfUint64(value) + case "tibc.lightclients.eth.v1.Header.baseFee": + value := x.BaseFee + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.Header")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.Header 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_Header) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.Header.parent_hash": + x.ParentHash = value.Bytes() + case "tibc.lightclients.eth.v1.Header.uncle_hash": + x.UncleHash = value.Bytes() + case "tibc.lightclients.eth.v1.Header.coinbase": + x.Coinbase = value.Bytes() + case "tibc.lightclients.eth.v1.Header.root": + x.Root = value.Bytes() + case "tibc.lightclients.eth.v1.Header.tx_hash": + x.TxHash = value.Bytes() + case "tibc.lightclients.eth.v1.Header.receipt_hash": + x.ReceiptHash = value.Bytes() + case "tibc.lightclients.eth.v1.Header.bloom": + x.Bloom = value.Bytes() + case "tibc.lightclients.eth.v1.Header.difficulty": + x.Difficulty = value.Interface().(string) + case "tibc.lightclients.eth.v1.Header.height": + x.Height = value.Message().Interface().(*v1.Height) + case "tibc.lightclients.eth.v1.Header.gas_limit": + x.GasLimit = value.Uint() + case "tibc.lightclients.eth.v1.Header.gas_used": + x.GasUsed = value.Uint() + case "tibc.lightclients.eth.v1.Header.time": + x.Time = value.Uint() + case "tibc.lightclients.eth.v1.Header.extra": + x.Extra = value.Bytes() + case "tibc.lightclients.eth.v1.Header.mix_digest": + x.MixDigest = value.Bytes() + case "tibc.lightclients.eth.v1.Header.nonce": + x.Nonce = value.Uint() + case "tibc.lightclients.eth.v1.Header.baseFee": + x.BaseFee = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.Header")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.Header 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_Header) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.Header.height": + if x.Height == nil { + x.Height = new(v1.Height) + } + return protoreflect.ValueOfMessage(x.Height.ProtoReflect()) + case "tibc.lightclients.eth.v1.Header.parent_hash": + panic(fmt.Errorf("field parent_hash of message tibc.lightclients.eth.v1.Header is not mutable")) + case "tibc.lightclients.eth.v1.Header.uncle_hash": + panic(fmt.Errorf("field uncle_hash of message tibc.lightclients.eth.v1.Header is not mutable")) + case "tibc.lightclients.eth.v1.Header.coinbase": + panic(fmt.Errorf("field coinbase of message tibc.lightclients.eth.v1.Header is not mutable")) + case "tibc.lightclients.eth.v1.Header.root": + panic(fmt.Errorf("field root of message tibc.lightclients.eth.v1.Header is not mutable")) + case "tibc.lightclients.eth.v1.Header.tx_hash": + panic(fmt.Errorf("field tx_hash of message tibc.lightclients.eth.v1.Header is not mutable")) + case "tibc.lightclients.eth.v1.Header.receipt_hash": + panic(fmt.Errorf("field receipt_hash of message tibc.lightclients.eth.v1.Header is not mutable")) + case "tibc.lightclients.eth.v1.Header.bloom": + panic(fmt.Errorf("field bloom of message tibc.lightclients.eth.v1.Header is not mutable")) + case "tibc.lightclients.eth.v1.Header.difficulty": + panic(fmt.Errorf("field difficulty of message tibc.lightclients.eth.v1.Header is not mutable")) + case "tibc.lightclients.eth.v1.Header.gas_limit": + panic(fmt.Errorf("field gas_limit of message tibc.lightclients.eth.v1.Header is not mutable")) + case "tibc.lightclients.eth.v1.Header.gas_used": + panic(fmt.Errorf("field gas_used of message tibc.lightclients.eth.v1.Header is not mutable")) + case "tibc.lightclients.eth.v1.Header.time": + panic(fmt.Errorf("field time of message tibc.lightclients.eth.v1.Header is not mutable")) + case "tibc.lightclients.eth.v1.Header.extra": + panic(fmt.Errorf("field extra of message tibc.lightclients.eth.v1.Header is not mutable")) + case "tibc.lightclients.eth.v1.Header.mix_digest": + panic(fmt.Errorf("field mix_digest of message tibc.lightclients.eth.v1.Header is not mutable")) + case "tibc.lightclients.eth.v1.Header.nonce": + panic(fmt.Errorf("field nonce of message tibc.lightclients.eth.v1.Header is not mutable")) + case "tibc.lightclients.eth.v1.Header.baseFee": + panic(fmt.Errorf("field baseFee of message tibc.lightclients.eth.v1.Header is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.Header")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.Header 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_Header) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.Header.parent_hash": + return protoreflect.ValueOfBytes(nil) + case "tibc.lightclients.eth.v1.Header.uncle_hash": + return protoreflect.ValueOfBytes(nil) + case "tibc.lightclients.eth.v1.Header.coinbase": + return protoreflect.ValueOfBytes(nil) + case "tibc.lightclients.eth.v1.Header.root": + return protoreflect.ValueOfBytes(nil) + case "tibc.lightclients.eth.v1.Header.tx_hash": + return protoreflect.ValueOfBytes(nil) + case "tibc.lightclients.eth.v1.Header.receipt_hash": + return protoreflect.ValueOfBytes(nil) + case "tibc.lightclients.eth.v1.Header.bloom": + return protoreflect.ValueOfBytes(nil) + case "tibc.lightclients.eth.v1.Header.difficulty": + return protoreflect.ValueOfString("") + case "tibc.lightclients.eth.v1.Header.height": + m := new(v1.Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.lightclients.eth.v1.Header.gas_limit": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.lightclients.eth.v1.Header.gas_used": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.lightclients.eth.v1.Header.time": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.lightclients.eth.v1.Header.extra": + return protoreflect.ValueOfBytes(nil) + case "tibc.lightclients.eth.v1.Header.mix_digest": + return protoreflect.ValueOfBytes(nil) + case "tibc.lightclients.eth.v1.Header.nonce": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.lightclients.eth.v1.Header.baseFee": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.Header")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.Header 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_Header) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.lightclients.eth.v1.Header", 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_Header) 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_Header) 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_Header) 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_Header) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Header) + 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.ParentHash) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.UncleHash) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Coinbase) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Root) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.TxHash) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.ReceiptHash) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Bloom) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Difficulty) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Height != nil { + l = options.Size(x.Height) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.GasLimit != 0 { + n += 1 + runtime.Sov(uint64(x.GasLimit)) + } + if x.GasUsed != 0 { + n += 1 + runtime.Sov(uint64(x.GasUsed)) + } + if x.Time != 0 { + n += 1 + runtime.Sov(uint64(x.Time)) + } + l = len(x.Extra) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.MixDigest) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Nonce != 0 { + n += 1 + runtime.Sov(uint64(x.Nonce)) + } + l = len(x.BaseFee) + if l > 0 { + n += 2 + 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().(*Header) + 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.BaseFee) > 0 { + i -= len(x.BaseFee) + copy(dAtA[i:], x.BaseFee) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.BaseFee))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + if x.Nonce != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Nonce)) + i-- + dAtA[i] = 0x78 + } + if len(x.MixDigest) > 0 { + i -= len(x.MixDigest) + copy(dAtA[i:], x.MixDigest) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MixDigest))) + i-- + dAtA[i] = 0x72 + } + if len(x.Extra) > 0 { + i -= len(x.Extra) + copy(dAtA[i:], x.Extra) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Extra))) + i-- + dAtA[i] = 0x6a + } + if x.Time != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Time)) + i-- + dAtA[i] = 0x60 + } + if x.GasUsed != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.GasUsed)) + i-- + dAtA[i] = 0x58 + } + if x.GasLimit != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.GasLimit)) + i-- + dAtA[i] = 0x50 + } + if x.Height != nil { + encoded, err := options.Marshal(x.Height) + 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] = 0x4a + } + if len(x.Difficulty) > 0 { + i -= len(x.Difficulty) + copy(dAtA[i:], x.Difficulty) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Difficulty))) + i-- + dAtA[i] = 0x42 + } + if len(x.Bloom) > 0 { + i -= len(x.Bloom) + copy(dAtA[i:], x.Bloom) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Bloom))) + i-- + dAtA[i] = 0x3a + } + if len(x.ReceiptHash) > 0 { + i -= len(x.ReceiptHash) + copy(dAtA[i:], x.ReceiptHash) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ReceiptHash))) + i-- + dAtA[i] = 0x32 + } + if len(x.TxHash) > 0 { + i -= len(x.TxHash) + copy(dAtA[i:], x.TxHash) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.TxHash))) + i-- + dAtA[i] = 0x2a + } + if len(x.Root) > 0 { + i -= len(x.Root) + copy(dAtA[i:], x.Root) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Root))) + i-- + dAtA[i] = 0x22 + } + if len(x.Coinbase) > 0 { + i -= len(x.Coinbase) + copy(dAtA[i:], x.Coinbase) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Coinbase))) + i-- + dAtA[i] = 0x1a + } + if len(x.UncleHash) > 0 { + i -= len(x.UncleHash) + copy(dAtA[i:], x.UncleHash) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.UncleHash))) + i-- + dAtA[i] = 0x12 + } + if len(x.ParentHash) > 0 { + i -= len(x.ParentHash) + copy(dAtA[i:], x.ParentHash) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ParentHash))) + 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().(*Header) + 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: Header: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Header: 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 ParentHash", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.ParentHash = append(x.ParentHash[:0], dAtA[iNdEx:postIndex]...) + if x.ParentHash == nil { + x.ParentHash = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UncleHash", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.UncleHash = append(x.UncleHash[:0], dAtA[iNdEx:postIndex]...) + if x.UncleHash == nil { + x.UncleHash = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Coinbase", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Coinbase = append(x.Coinbase[:0], dAtA[iNdEx:postIndex]...) + if x.Coinbase == nil { + x.Coinbase = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Root", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Root = append(x.Root[:0], dAtA[iNdEx:postIndex]...) + if x.Root == nil { + x.Root = []byte{} + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TxHash", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.TxHash = append(x.TxHash[:0], dAtA[iNdEx:postIndex]...) + if x.TxHash == nil { + x.TxHash = []byte{} + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ReceiptHash", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.ReceiptHash = append(x.ReceiptHash[:0], dAtA[iNdEx:postIndex]...) + if x.ReceiptHash == nil { + x.ReceiptHash = []byte{} + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Bloom", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Bloom = append(x.Bloom[:0], dAtA[iNdEx:postIndex]...) + if x.Bloom == nil { + x.Bloom = []byte{} + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Difficulty", 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.Difficulty = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Height", 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.Height == nil { + x.Height = &v1.Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Height); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 10: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + x.GasLimit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.GasLimit |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 11: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + x.GasUsed = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.GasUsed |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 12: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Time", wireType) + } + x.Time = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Time |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 13: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Extra", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Extra = append(x.Extra[:0], dAtA[iNdEx:postIndex]...) + if x.Extra == nil { + x.Extra = []byte{} + } + iNdEx = postIndex + case 14: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MixDigest", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.MixDigest = append(x.MixDigest[:0], dAtA[iNdEx:postIndex]...) + if x.MixDigest == nil { + x.MixDigest = []byte{} + } + iNdEx = postIndex + case 15: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType) + } + x.Nonce = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Nonce |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 16: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BaseFee", 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.BaseFee = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_ClientState protoreflect.MessageDescriptor + fd_ClientState_header protoreflect.FieldDescriptor + fd_ClientState_chain_id protoreflect.FieldDescriptor + fd_ClientState_contract_address protoreflect.FieldDescriptor + fd_ClientState_trusting_period protoreflect.FieldDescriptor + fd_ClientState_timeDelay protoreflect.FieldDescriptor + fd_ClientState_blockDelay protoreflect.FieldDescriptor +) + +func init() { + file_tibc_lightclients_eth_v1_eth_proto_init() + md_ClientState = File_tibc_lightclients_eth_v1_eth_proto.Messages().ByName("ClientState") + fd_ClientState_header = md_ClientState.Fields().ByName("header") + fd_ClientState_chain_id = md_ClientState.Fields().ByName("chain_id") + fd_ClientState_contract_address = md_ClientState.Fields().ByName("contract_address") + fd_ClientState_trusting_period = md_ClientState.Fields().ByName("trusting_period") + fd_ClientState_timeDelay = md_ClientState.Fields().ByName("timeDelay") + fd_ClientState_blockDelay = md_ClientState.Fields().ByName("blockDelay") +} + +var _ protoreflect.Message = (*fastReflection_ClientState)(nil) + +type fastReflection_ClientState ClientState + +func (x *ClientState) ProtoReflect() protoreflect.Message { + return (*fastReflection_ClientState)(x) +} + +func (x *ClientState) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_lightclients_eth_v1_eth_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_ClientState_messageType fastReflection_ClientState_messageType +var _ protoreflect.MessageType = fastReflection_ClientState_messageType{} + +type fastReflection_ClientState_messageType struct{} + +func (x fastReflection_ClientState_messageType) Zero() protoreflect.Message { + return (*fastReflection_ClientState)(nil) +} +func (x fastReflection_ClientState_messageType) New() protoreflect.Message { + return new(fastReflection_ClientState) +} +func (x fastReflection_ClientState_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_ClientState +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_ClientState) Descriptor() protoreflect.MessageDescriptor { + return md_ClientState +} + +// 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_ClientState) Type() protoreflect.MessageType { + return _fastReflection_ClientState_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_ClientState) New() protoreflect.Message { + return new(fastReflection_ClientState) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_ClientState) Interface() protoreflect.ProtoMessage { + return (*ClientState)(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_ClientState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Header != nil { + value := protoreflect.ValueOfMessage(x.Header.ProtoReflect()) + if !f(fd_ClientState_header, value) { + return + } + } + if x.ChainId != uint64(0) { + value := protoreflect.ValueOfUint64(x.ChainId) + if !f(fd_ClientState_chain_id, value) { + return + } + } + if len(x.ContractAddress) != 0 { + value := protoreflect.ValueOfBytes(x.ContractAddress) + if !f(fd_ClientState_contract_address, value) { + return + } + } + if x.TrustingPeriod != uint64(0) { + value := protoreflect.ValueOfUint64(x.TrustingPeriod) + if !f(fd_ClientState_trusting_period, value) { + return + } + } + if x.TimeDelay != uint64(0) { + value := protoreflect.ValueOfUint64(x.TimeDelay) + if !f(fd_ClientState_timeDelay, value) { + return + } + } + if x.BlockDelay != uint64(0) { + value := protoreflect.ValueOfUint64(x.BlockDelay) + if !f(fd_ClientState_blockDelay, 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_ClientState) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.ClientState.header": + return x.Header != nil + case "tibc.lightclients.eth.v1.ClientState.chain_id": + return x.ChainId != uint64(0) + case "tibc.lightclients.eth.v1.ClientState.contract_address": + return len(x.ContractAddress) != 0 + case "tibc.lightclients.eth.v1.ClientState.trusting_period": + return x.TrustingPeriod != uint64(0) + case "tibc.lightclients.eth.v1.ClientState.timeDelay": + return x.TimeDelay != uint64(0) + case "tibc.lightclients.eth.v1.ClientState.blockDelay": + return x.BlockDelay != uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.ClientState")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.ClientState 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_ClientState) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.ClientState.header": + x.Header = nil + case "tibc.lightclients.eth.v1.ClientState.chain_id": + x.ChainId = uint64(0) + case "tibc.lightclients.eth.v1.ClientState.contract_address": + x.ContractAddress = nil + case "tibc.lightclients.eth.v1.ClientState.trusting_period": + x.TrustingPeriod = uint64(0) + case "tibc.lightclients.eth.v1.ClientState.timeDelay": + x.TimeDelay = uint64(0) + case "tibc.lightclients.eth.v1.ClientState.blockDelay": + x.BlockDelay = uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.ClientState")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.ClientState 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_ClientState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.lightclients.eth.v1.ClientState.header": + value := x.Header + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.lightclients.eth.v1.ClientState.chain_id": + value := x.ChainId + return protoreflect.ValueOfUint64(value) + case "tibc.lightclients.eth.v1.ClientState.contract_address": + value := x.ContractAddress + return protoreflect.ValueOfBytes(value) + case "tibc.lightclients.eth.v1.ClientState.trusting_period": + value := x.TrustingPeriod + return protoreflect.ValueOfUint64(value) + case "tibc.lightclients.eth.v1.ClientState.timeDelay": + value := x.TimeDelay + return protoreflect.ValueOfUint64(value) + case "tibc.lightclients.eth.v1.ClientState.blockDelay": + value := x.BlockDelay + return protoreflect.ValueOfUint64(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.ClientState")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.ClientState 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_ClientState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.ClientState.header": + x.Header = value.Message().Interface().(*Header) + case "tibc.lightclients.eth.v1.ClientState.chain_id": + x.ChainId = value.Uint() + case "tibc.lightclients.eth.v1.ClientState.contract_address": + x.ContractAddress = value.Bytes() + case "tibc.lightclients.eth.v1.ClientState.trusting_period": + x.TrustingPeriod = value.Uint() + case "tibc.lightclients.eth.v1.ClientState.timeDelay": + x.TimeDelay = value.Uint() + case "tibc.lightclients.eth.v1.ClientState.blockDelay": + x.BlockDelay = value.Uint() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.ClientState")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.ClientState 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_ClientState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.ClientState.header": + if x.Header == nil { + x.Header = new(Header) + } + return protoreflect.ValueOfMessage(x.Header.ProtoReflect()) + case "tibc.lightclients.eth.v1.ClientState.chain_id": + panic(fmt.Errorf("field chain_id of message tibc.lightclients.eth.v1.ClientState is not mutable")) + case "tibc.lightclients.eth.v1.ClientState.contract_address": + panic(fmt.Errorf("field contract_address of message tibc.lightclients.eth.v1.ClientState is not mutable")) + case "tibc.lightclients.eth.v1.ClientState.trusting_period": + panic(fmt.Errorf("field trusting_period of message tibc.lightclients.eth.v1.ClientState is not mutable")) + case "tibc.lightclients.eth.v1.ClientState.timeDelay": + panic(fmt.Errorf("field timeDelay of message tibc.lightclients.eth.v1.ClientState is not mutable")) + case "tibc.lightclients.eth.v1.ClientState.blockDelay": + panic(fmt.Errorf("field blockDelay of message tibc.lightclients.eth.v1.ClientState is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.ClientState")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.ClientState 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_ClientState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.ClientState.header": + m := new(Header) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.lightclients.eth.v1.ClientState.chain_id": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.lightclients.eth.v1.ClientState.contract_address": + return protoreflect.ValueOfBytes(nil) + case "tibc.lightclients.eth.v1.ClientState.trusting_period": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.lightclients.eth.v1.ClientState.timeDelay": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.lightclients.eth.v1.ClientState.blockDelay": + return protoreflect.ValueOfUint64(uint64(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.ClientState")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.ClientState 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_ClientState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.lightclients.eth.v1.ClientState", 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_ClientState) 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_ClientState) 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_ClientState) 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_ClientState) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*ClientState) + 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.Header != nil { + l = options.Size(x.Header) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ChainId != 0 { + n += 1 + runtime.Sov(uint64(x.ChainId)) + } + l = len(x.ContractAddress) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.TrustingPeriod != 0 { + n += 1 + runtime.Sov(uint64(x.TrustingPeriod)) + } + if x.TimeDelay != 0 { + n += 1 + runtime.Sov(uint64(x.TimeDelay)) + } + if x.BlockDelay != 0 { + n += 1 + runtime.Sov(uint64(x.BlockDelay)) + } + 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().(*ClientState) + 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.BlockDelay != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockDelay)) + i-- + dAtA[i] = 0x30 + } + if x.TimeDelay != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.TimeDelay)) + i-- + dAtA[i] = 0x28 + } + if x.TrustingPeriod != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.TrustingPeriod)) + i-- + dAtA[i] = 0x20 + } + if len(x.ContractAddress) > 0 { + i -= len(x.ContractAddress) + copy(dAtA[i:], x.ContractAddress) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ContractAddress))) + i-- + dAtA[i] = 0x1a + } + if x.ChainId != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.ChainId)) + i-- + dAtA[i] = 0x10 + } + if x.Header != nil { + encoded, err := options.Marshal(x.Header) + 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().(*ClientState) + 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: ClientState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ClientState: 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 Header", 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.Header == nil { + x.Header = &Header{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Header); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + x.ChainId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.ChainId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.ContractAddress = append(x.ContractAddress[:0], dAtA[iNdEx:postIndex]...) + if x.ContractAddress == nil { + x.ContractAddress = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TrustingPeriod", wireType) + } + x.TrustingPeriod = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.TrustingPeriod |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TimeDelay", wireType) + } + x.TimeDelay = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.TimeDelay |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockDelay", wireType) + } + x.BlockDelay = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.BlockDelay |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_ConsensusState protoreflect.MessageDescriptor + fd_ConsensusState_timestamp protoreflect.FieldDescriptor + fd_ConsensusState_number protoreflect.FieldDescriptor + fd_ConsensusState_root protoreflect.FieldDescriptor +) + +func init() { + file_tibc_lightclients_eth_v1_eth_proto_init() + md_ConsensusState = File_tibc_lightclients_eth_v1_eth_proto.Messages().ByName("ConsensusState") + fd_ConsensusState_timestamp = md_ConsensusState.Fields().ByName("timestamp") + fd_ConsensusState_number = md_ConsensusState.Fields().ByName("number") + fd_ConsensusState_root = md_ConsensusState.Fields().ByName("root") +} + +var _ protoreflect.Message = (*fastReflection_ConsensusState)(nil) + +type fastReflection_ConsensusState ConsensusState + +func (x *ConsensusState) ProtoReflect() protoreflect.Message { + return (*fastReflection_ConsensusState)(x) +} + +func (x *ConsensusState) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_lightclients_eth_v1_eth_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_ConsensusState_messageType fastReflection_ConsensusState_messageType +var _ protoreflect.MessageType = fastReflection_ConsensusState_messageType{} + +type fastReflection_ConsensusState_messageType struct{} + +func (x fastReflection_ConsensusState_messageType) Zero() protoreflect.Message { + return (*fastReflection_ConsensusState)(nil) +} +func (x fastReflection_ConsensusState_messageType) New() protoreflect.Message { + return new(fastReflection_ConsensusState) +} +func (x fastReflection_ConsensusState_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_ConsensusState +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_ConsensusState) Descriptor() protoreflect.MessageDescriptor { + return md_ConsensusState +} + +// 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_ConsensusState) Type() protoreflect.MessageType { + return _fastReflection_ConsensusState_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_ConsensusState) New() protoreflect.Message { + return new(fastReflection_ConsensusState) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_ConsensusState) Interface() protoreflect.ProtoMessage { + return (*ConsensusState)(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_ConsensusState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Timestamp != uint64(0) { + value := protoreflect.ValueOfUint64(x.Timestamp) + if !f(fd_ConsensusState_timestamp, value) { + return + } + } + if x.Number != nil { + value := protoreflect.ValueOfMessage(x.Number.ProtoReflect()) + if !f(fd_ConsensusState_number, value) { + return + } + } + if len(x.Root) != 0 { + value := protoreflect.ValueOfBytes(x.Root) + if !f(fd_ConsensusState_root, 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_ConsensusState) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.ConsensusState.timestamp": + return x.Timestamp != uint64(0) + case "tibc.lightclients.eth.v1.ConsensusState.number": + return x.Number != nil + case "tibc.lightclients.eth.v1.ConsensusState.root": + return len(x.Root) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.ConsensusState")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.ConsensusState 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_ConsensusState) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.ConsensusState.timestamp": + x.Timestamp = uint64(0) + case "tibc.lightclients.eth.v1.ConsensusState.number": + x.Number = nil + case "tibc.lightclients.eth.v1.ConsensusState.root": + x.Root = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.ConsensusState")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.ConsensusState 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_ConsensusState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.lightclients.eth.v1.ConsensusState.timestamp": + value := x.Timestamp + return protoreflect.ValueOfUint64(value) + case "tibc.lightclients.eth.v1.ConsensusState.number": + value := x.Number + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.lightclients.eth.v1.ConsensusState.root": + value := x.Root + return protoreflect.ValueOfBytes(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.ConsensusState")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.ConsensusState 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_ConsensusState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.ConsensusState.timestamp": + x.Timestamp = value.Uint() + case "tibc.lightclients.eth.v1.ConsensusState.number": + x.Number = value.Message().Interface().(*v1.Height) + case "tibc.lightclients.eth.v1.ConsensusState.root": + x.Root = value.Bytes() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.ConsensusState")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.ConsensusState 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_ConsensusState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.ConsensusState.number": + if x.Number == nil { + x.Number = new(v1.Height) + } + return protoreflect.ValueOfMessage(x.Number.ProtoReflect()) + case "tibc.lightclients.eth.v1.ConsensusState.timestamp": + panic(fmt.Errorf("field timestamp of message tibc.lightclients.eth.v1.ConsensusState is not mutable")) + case "tibc.lightclients.eth.v1.ConsensusState.root": + panic(fmt.Errorf("field root of message tibc.lightclients.eth.v1.ConsensusState is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.ConsensusState")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.ConsensusState 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_ConsensusState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.ConsensusState.timestamp": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.lightclients.eth.v1.ConsensusState.number": + m := new(v1.Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.lightclients.eth.v1.ConsensusState.root": + return protoreflect.ValueOfBytes(nil) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.ConsensusState")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.ConsensusState 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_ConsensusState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.lightclients.eth.v1.ConsensusState", 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_ConsensusState) 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_ConsensusState) 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_ConsensusState) 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_ConsensusState) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*ConsensusState) + 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.Timestamp != 0 { + n += 1 + runtime.Sov(uint64(x.Timestamp)) + } + if x.Number != nil { + l = options.Size(x.Number) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Root) + 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().(*ConsensusState) + 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.Root) > 0 { + i -= len(x.Root) + copy(dAtA[i:], x.Root) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Root))) + i-- + dAtA[i] = 0x1a + } + if x.Number != nil { + encoded, err := options.Marshal(x.Number) + 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 x.Timestamp != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Timestamp)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*ConsensusState) + 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: ConsensusState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ConsensusState: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + x.Timestamp = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Timestamp |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Number", 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.Number == nil { + x.Number = &v1.Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Number); 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 Root", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.Root = append(x.Root[:0], dAtA[iNdEx:postIndex]...) + if x.Root == nil { + x.Root = []byte{} + } + 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 = (*_StorageResult_3_list)(nil) + +type _StorageResult_3_list struct { + list *[]string +} + +func (x *_StorageResult_3_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_StorageResult_3_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfString((*x.list)[i]) +} + +func (x *_StorageResult_3_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_StorageResult_3_list) Append(value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_StorageResult_3_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message StorageResult at list field Proof as it is not of Message kind")) +} + +func (x *_StorageResult_3_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_StorageResult_3_list) NewElement() protoreflect.Value { + v := "" + return protoreflect.ValueOfString(v) +} + +func (x *_StorageResult_3_list) IsValid() bool { + return x.list != nil +} + +var ( + md_StorageResult protoreflect.MessageDescriptor + fd_StorageResult_key protoreflect.FieldDescriptor + fd_StorageResult_value protoreflect.FieldDescriptor + fd_StorageResult_proof protoreflect.FieldDescriptor +) + +func init() { + file_tibc_lightclients_eth_v1_eth_proto_init() + md_StorageResult = File_tibc_lightclients_eth_v1_eth_proto.Messages().ByName("StorageResult") + fd_StorageResult_key = md_StorageResult.Fields().ByName("key") + fd_StorageResult_value = md_StorageResult.Fields().ByName("value") + fd_StorageResult_proof = md_StorageResult.Fields().ByName("proof") +} + +var _ protoreflect.Message = (*fastReflection_StorageResult)(nil) + +type fastReflection_StorageResult StorageResult + +func (x *StorageResult) ProtoReflect() protoreflect.Message { + return (*fastReflection_StorageResult)(x) +} + +func (x *StorageResult) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_lightclients_eth_v1_eth_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_StorageResult_messageType fastReflection_StorageResult_messageType +var _ protoreflect.MessageType = fastReflection_StorageResult_messageType{} + +type fastReflection_StorageResult_messageType struct{} + +func (x fastReflection_StorageResult_messageType) Zero() protoreflect.Message { + return (*fastReflection_StorageResult)(nil) +} +func (x fastReflection_StorageResult_messageType) New() protoreflect.Message { + return new(fastReflection_StorageResult) +} +func (x fastReflection_StorageResult_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_StorageResult +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_StorageResult) Descriptor() protoreflect.MessageDescriptor { + return md_StorageResult +} + +// 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_StorageResult) Type() protoreflect.MessageType { + return _fastReflection_StorageResult_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_StorageResult) New() protoreflect.Message { + return new(fastReflection_StorageResult) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_StorageResult) Interface() protoreflect.ProtoMessage { + return (*StorageResult)(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_StorageResult) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Key != "" { + value := protoreflect.ValueOfString(x.Key) + if !f(fd_StorageResult_key, value) { + return + } + } + if x.Value != "" { + value := protoreflect.ValueOfString(x.Value) + if !f(fd_StorageResult_value, value) { + return + } + } + if len(x.Proof) != 0 { + value := protoreflect.ValueOfList(&_StorageResult_3_list{list: &x.Proof}) + if !f(fd_StorageResult_proof, 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_StorageResult) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.StorageResult.key": + return x.Key != "" + case "tibc.lightclients.eth.v1.StorageResult.value": + return x.Value != "" + case "tibc.lightclients.eth.v1.StorageResult.proof": + return len(x.Proof) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.StorageResult")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.StorageResult 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_StorageResult) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.StorageResult.key": + x.Key = "" + case "tibc.lightclients.eth.v1.StorageResult.value": + x.Value = "" + case "tibc.lightclients.eth.v1.StorageResult.proof": + x.Proof = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.StorageResult")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.StorageResult 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_StorageResult) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.lightclients.eth.v1.StorageResult.key": + value := x.Key + return protoreflect.ValueOfString(value) + case "tibc.lightclients.eth.v1.StorageResult.value": + value := x.Value + return protoreflect.ValueOfString(value) + case "tibc.lightclients.eth.v1.StorageResult.proof": + if len(x.Proof) == 0 { + return protoreflect.ValueOfList(&_StorageResult_3_list{}) + } + listValue := &_StorageResult_3_list{list: &x.Proof} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.StorageResult")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.StorageResult 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_StorageResult) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.StorageResult.key": + x.Key = value.Interface().(string) + case "tibc.lightclients.eth.v1.StorageResult.value": + x.Value = value.Interface().(string) + case "tibc.lightclients.eth.v1.StorageResult.proof": + lv := value.List() + clv := lv.(*_StorageResult_3_list) + x.Proof = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.StorageResult")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.StorageResult 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_StorageResult) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.StorageResult.proof": + if x.Proof == nil { + x.Proof = []string{} + } + value := &_StorageResult_3_list{list: &x.Proof} + return protoreflect.ValueOfList(value) + case "tibc.lightclients.eth.v1.StorageResult.key": + panic(fmt.Errorf("field key of message tibc.lightclients.eth.v1.StorageResult is not mutable")) + case "tibc.lightclients.eth.v1.StorageResult.value": + panic(fmt.Errorf("field value of message tibc.lightclients.eth.v1.StorageResult is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.StorageResult")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.StorageResult 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_StorageResult) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.StorageResult.key": + return protoreflect.ValueOfString("") + case "tibc.lightclients.eth.v1.StorageResult.value": + return protoreflect.ValueOfString("") + case "tibc.lightclients.eth.v1.StorageResult.proof": + list := []string{} + return protoreflect.ValueOfList(&_StorageResult_3_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.StorageResult")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.StorageResult 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_StorageResult) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.lightclients.eth.v1.StorageResult", 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_StorageResult) 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_StorageResult) 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_StorageResult) 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_StorageResult) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*StorageResult) + 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.Key) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Value) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.Proof) > 0 { + for _, s := range x.Proof { + l = len(s) + 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().(*StorageResult) + 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.Proof) > 0 { + for iNdEx := len(x.Proof) - 1; iNdEx >= 0; iNdEx-- { + i -= len(x.Proof[iNdEx]) + copy(dAtA[i:], x.Proof[iNdEx]) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Proof[iNdEx]))) + i-- + dAtA[i] = 0x1a + } + } + if len(x.Value) > 0 { + i -= len(x.Value) + copy(dAtA[i:], x.Value) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Value))) + i-- + dAtA[i] = 0x12 + } + if len(x.Key) > 0 { + i -= len(x.Key) + copy(dAtA[i:], x.Key) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Key))) + 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().(*StorageResult) + 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: StorageResult: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: StorageResult: 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 Key", 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.Key = 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 Value", 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.Value = 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 Proof", 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.Proof = append(x.Proof, 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 = (*_Proof_6_list)(nil) + +type _Proof_6_list struct { + list *[]string +} + +func (x *_Proof_6_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_Proof_6_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfString((*x.list)[i]) +} + +func (x *_Proof_6_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_Proof_6_list) Append(value protoreflect.Value) { + valueUnwrapped := value.String() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_Proof_6_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message Proof at list field AccountProof as it is not of Message kind")) +} + +func (x *_Proof_6_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_Proof_6_list) NewElement() protoreflect.Value { + v := "" + return protoreflect.ValueOfString(v) +} + +func (x *_Proof_6_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_Proof_7_list)(nil) + +type _Proof_7_list struct { + list *[]*StorageResult +} + +func (x *_Proof_7_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_Proof_7_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_Proof_7_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*StorageResult) + (*x.list)[i] = concreteValue +} + +func (x *_Proof_7_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*StorageResult) + *x.list = append(*x.list, concreteValue) +} + +func (x *_Proof_7_list) AppendMutable() protoreflect.Value { + v := new(StorageResult) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_Proof_7_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_Proof_7_list) NewElement() protoreflect.Value { + v := new(StorageResult) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_Proof_7_list) IsValid() bool { + return x.list != nil +} + +var ( + md_Proof protoreflect.MessageDescriptor + fd_Proof_address protoreflect.FieldDescriptor + fd_Proof_balance protoreflect.FieldDescriptor + fd_Proof_code_hash protoreflect.FieldDescriptor + fd_Proof_nonce protoreflect.FieldDescriptor + fd_Proof_storage_hash protoreflect.FieldDescriptor + fd_Proof_account_proof protoreflect.FieldDescriptor + fd_Proof_storage_proof protoreflect.FieldDescriptor +) + +func init() { + file_tibc_lightclients_eth_v1_eth_proto_init() + md_Proof = File_tibc_lightclients_eth_v1_eth_proto.Messages().ByName("Proof") + fd_Proof_address = md_Proof.Fields().ByName("address") + fd_Proof_balance = md_Proof.Fields().ByName("balance") + fd_Proof_code_hash = md_Proof.Fields().ByName("code_hash") + fd_Proof_nonce = md_Proof.Fields().ByName("nonce") + fd_Proof_storage_hash = md_Proof.Fields().ByName("storage_hash") + fd_Proof_account_proof = md_Proof.Fields().ByName("account_proof") + fd_Proof_storage_proof = md_Proof.Fields().ByName("storage_proof") +} + +var _ protoreflect.Message = (*fastReflection_Proof)(nil) + +type fastReflection_Proof Proof + +func (x *Proof) ProtoReflect() protoreflect.Message { + return (*fastReflection_Proof)(x) +} + +func (x *Proof) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_lightclients_eth_v1_eth_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_Proof_messageType fastReflection_Proof_messageType +var _ protoreflect.MessageType = fastReflection_Proof_messageType{} + +type fastReflection_Proof_messageType struct{} + +func (x fastReflection_Proof_messageType) Zero() protoreflect.Message { + return (*fastReflection_Proof)(nil) +} +func (x fastReflection_Proof_messageType) New() protoreflect.Message { + return new(fastReflection_Proof) +} +func (x fastReflection_Proof_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Proof +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Proof) Descriptor() protoreflect.MessageDescriptor { + return md_Proof +} + +// 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_Proof) Type() protoreflect.MessageType { + return _fastReflection_Proof_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Proof) New() protoreflect.Message { + return new(fastReflection_Proof) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Proof) Interface() protoreflect.ProtoMessage { + return (*Proof)(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_Proof) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Address != "" { + value := protoreflect.ValueOfString(x.Address) + if !f(fd_Proof_address, value) { + return + } + } + if x.Balance != "" { + value := protoreflect.ValueOfString(x.Balance) + if !f(fd_Proof_balance, value) { + return + } + } + if x.CodeHash != "" { + value := protoreflect.ValueOfString(x.CodeHash) + if !f(fd_Proof_code_hash, value) { + return + } + } + if x.Nonce != "" { + value := protoreflect.ValueOfString(x.Nonce) + if !f(fd_Proof_nonce, value) { + return + } + } + if x.StorageHash != "" { + value := protoreflect.ValueOfString(x.StorageHash) + if !f(fd_Proof_storage_hash, value) { + return + } + } + if len(x.AccountProof) != 0 { + value := protoreflect.ValueOfList(&_Proof_6_list{list: &x.AccountProof}) + if !f(fd_Proof_account_proof, value) { + return + } + } + if len(x.StorageProof) != 0 { + value := protoreflect.ValueOfList(&_Proof_7_list{list: &x.StorageProof}) + if !f(fd_Proof_storage_proof, 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_Proof) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.Proof.address": + return x.Address != "" + case "tibc.lightclients.eth.v1.Proof.balance": + return x.Balance != "" + case "tibc.lightclients.eth.v1.Proof.code_hash": + return x.CodeHash != "" + case "tibc.lightclients.eth.v1.Proof.nonce": + return x.Nonce != "" + case "tibc.lightclients.eth.v1.Proof.storage_hash": + return x.StorageHash != "" + case "tibc.lightclients.eth.v1.Proof.account_proof": + return len(x.AccountProof) != 0 + case "tibc.lightclients.eth.v1.Proof.storage_proof": + return len(x.StorageProof) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.Proof")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.Proof 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_Proof) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.Proof.address": + x.Address = "" + case "tibc.lightclients.eth.v1.Proof.balance": + x.Balance = "" + case "tibc.lightclients.eth.v1.Proof.code_hash": + x.CodeHash = "" + case "tibc.lightclients.eth.v1.Proof.nonce": + x.Nonce = "" + case "tibc.lightclients.eth.v1.Proof.storage_hash": + x.StorageHash = "" + case "tibc.lightclients.eth.v1.Proof.account_proof": + x.AccountProof = nil + case "tibc.lightclients.eth.v1.Proof.storage_proof": + x.StorageProof = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.Proof")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.Proof 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_Proof) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.lightclients.eth.v1.Proof.address": + value := x.Address + return protoreflect.ValueOfString(value) + case "tibc.lightclients.eth.v1.Proof.balance": + value := x.Balance + return protoreflect.ValueOfString(value) + case "tibc.lightclients.eth.v1.Proof.code_hash": + value := x.CodeHash + return protoreflect.ValueOfString(value) + case "tibc.lightclients.eth.v1.Proof.nonce": + value := x.Nonce + return protoreflect.ValueOfString(value) + case "tibc.lightclients.eth.v1.Proof.storage_hash": + value := x.StorageHash + return protoreflect.ValueOfString(value) + case "tibc.lightclients.eth.v1.Proof.account_proof": + if len(x.AccountProof) == 0 { + return protoreflect.ValueOfList(&_Proof_6_list{}) + } + listValue := &_Proof_6_list{list: &x.AccountProof} + return protoreflect.ValueOfList(listValue) + case "tibc.lightclients.eth.v1.Proof.storage_proof": + if len(x.StorageProof) == 0 { + return protoreflect.ValueOfList(&_Proof_7_list{}) + } + listValue := &_Proof_7_list{list: &x.StorageProof} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.Proof")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.Proof 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_Proof) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.Proof.address": + x.Address = value.Interface().(string) + case "tibc.lightclients.eth.v1.Proof.balance": + x.Balance = value.Interface().(string) + case "tibc.lightclients.eth.v1.Proof.code_hash": + x.CodeHash = value.Interface().(string) + case "tibc.lightclients.eth.v1.Proof.nonce": + x.Nonce = value.Interface().(string) + case "tibc.lightclients.eth.v1.Proof.storage_hash": + x.StorageHash = value.Interface().(string) + case "tibc.lightclients.eth.v1.Proof.account_proof": + lv := value.List() + clv := lv.(*_Proof_6_list) + x.AccountProof = *clv.list + case "tibc.lightclients.eth.v1.Proof.storage_proof": + lv := value.List() + clv := lv.(*_Proof_7_list) + x.StorageProof = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.Proof")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.Proof 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_Proof) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.Proof.account_proof": + if x.AccountProof == nil { + x.AccountProof = []string{} + } + value := &_Proof_6_list{list: &x.AccountProof} + return protoreflect.ValueOfList(value) + case "tibc.lightclients.eth.v1.Proof.storage_proof": + if x.StorageProof == nil { + x.StorageProof = []*StorageResult{} + } + value := &_Proof_7_list{list: &x.StorageProof} + return protoreflect.ValueOfList(value) + case "tibc.lightclients.eth.v1.Proof.address": + panic(fmt.Errorf("field address of message tibc.lightclients.eth.v1.Proof is not mutable")) + case "tibc.lightclients.eth.v1.Proof.balance": + panic(fmt.Errorf("field balance of message tibc.lightclients.eth.v1.Proof is not mutable")) + case "tibc.lightclients.eth.v1.Proof.code_hash": + panic(fmt.Errorf("field code_hash of message tibc.lightclients.eth.v1.Proof is not mutable")) + case "tibc.lightclients.eth.v1.Proof.nonce": + panic(fmt.Errorf("field nonce of message tibc.lightclients.eth.v1.Proof is not mutable")) + case "tibc.lightclients.eth.v1.Proof.storage_hash": + panic(fmt.Errorf("field storage_hash of message tibc.lightclients.eth.v1.Proof is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.Proof")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.Proof 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_Proof) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.eth.v1.Proof.address": + return protoreflect.ValueOfString("") + case "tibc.lightclients.eth.v1.Proof.balance": + return protoreflect.ValueOfString("") + case "tibc.lightclients.eth.v1.Proof.code_hash": + return protoreflect.ValueOfString("") + case "tibc.lightclients.eth.v1.Proof.nonce": + return protoreflect.ValueOfString("") + case "tibc.lightclients.eth.v1.Proof.storage_hash": + return protoreflect.ValueOfString("") + case "tibc.lightclients.eth.v1.Proof.account_proof": + list := []string{} + return protoreflect.ValueOfList(&_Proof_6_list{list: &list}) + case "tibc.lightclients.eth.v1.Proof.storage_proof": + list := []*StorageResult{} + return protoreflect.ValueOfList(&_Proof_7_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.eth.v1.Proof")) + } + panic(fmt.Errorf("message tibc.lightclients.eth.v1.Proof 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_Proof) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.lightclients.eth.v1.Proof", 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_Proof) 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_Proof) 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_Proof) 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_Proof) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Proof) + 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.Address) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Balance) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.CodeHash) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Nonce) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.StorageHash) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.AccountProof) > 0 { + for _, s := range x.AccountProof { + l = len(s) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if len(x.StorageProof) > 0 { + for _, e := range x.StorageProof { + 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().(*Proof) + 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.StorageProof) > 0 { + for iNdEx := len(x.StorageProof) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.StorageProof[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] = 0x3a + } + } + if len(x.AccountProof) > 0 { + for iNdEx := len(x.AccountProof) - 1; iNdEx >= 0; iNdEx-- { + i -= len(x.AccountProof[iNdEx]) + copy(dAtA[i:], x.AccountProof[iNdEx]) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.AccountProof[iNdEx]))) + i-- + dAtA[i] = 0x32 + } + } + if len(x.StorageHash) > 0 { + i -= len(x.StorageHash) + copy(dAtA[i:], x.StorageHash) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.StorageHash))) + i-- + dAtA[i] = 0x2a + } + if len(x.Nonce) > 0 { + i -= len(x.Nonce) + copy(dAtA[i:], x.Nonce) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Nonce))) + i-- + dAtA[i] = 0x22 + } + if len(x.CodeHash) > 0 { + i -= len(x.CodeHash) + copy(dAtA[i:], x.CodeHash) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.CodeHash))) + i-- + dAtA[i] = 0x1a + } + if len(x.Balance) > 0 { + i -= len(x.Balance) + copy(dAtA[i:], x.Balance) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Balance))) + i-- + dAtA[i] = 0x12 + } + if len(x.Address) > 0 { + i -= len(x.Address) + copy(dAtA[i:], x.Address) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Address))) + 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().(*Proof) + 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: Proof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Proof: 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 Address", 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.Address = 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 Balance", 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.Balance = 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 CodeHash", 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.CodeHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nonce", 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.Nonce = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StorageHash", 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.StorageHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field AccountProof", 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.AccountProof = append(x.AccountProof, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StorageProof", 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.StorageProof = append(x.StorageProof, &StorageResult{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.StorageProof[len(x.StorageProof)-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: tibc/lightclients/eth/v1/eth.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) +) + +// Header defines the eth client consensus Header. +type Header struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ParentHash []byte `protobuf:"bytes,1,opt,name=parent_hash,json=parentHash,proto3" json:"parent_hash,omitempty"` + UncleHash []byte `protobuf:"bytes,2,opt,name=uncle_hash,json=uncleHash,proto3" json:"uncle_hash,omitempty"` + Coinbase []byte `protobuf:"bytes,3,opt,name=coinbase,proto3" json:"coinbase,omitempty"` + Root []byte `protobuf:"bytes,4,opt,name=root,proto3" json:"root,omitempty"` + TxHash []byte `protobuf:"bytes,5,opt,name=tx_hash,json=txHash,proto3" json:"tx_hash,omitempty"` + ReceiptHash []byte `protobuf:"bytes,6,opt,name=receipt_hash,json=receiptHash,proto3" json:"receipt_hash,omitempty"` + Bloom []byte `protobuf:"bytes,7,opt,name=bloom,proto3" json:"bloom,omitempty"` + Difficulty string `protobuf:"bytes,8,opt,name=difficulty,proto3" json:"difficulty,omitempty"` + Height *v1.Height `protobuf:"bytes,9,opt,name=height,proto3" json:"height,omitempty"` + GasLimit uint64 `protobuf:"varint,10,opt,name=gas_limit,json=gasLimit,proto3" json:"gas_limit,omitempty"` + GasUsed uint64 `protobuf:"varint,11,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"` + Time uint64 `protobuf:"varint,12,opt,name=time,proto3" json:"time,omitempty"` + Extra []byte `protobuf:"bytes,13,opt,name=extra,proto3" json:"extra,omitempty"` + MixDigest []byte `protobuf:"bytes,14,opt,name=mix_digest,json=mixDigest,proto3" json:"mix_digest,omitempty"` + Nonce uint64 `protobuf:"varint,15,opt,name=nonce,proto3" json:"nonce,omitempty"` + BaseFee string `protobuf:"bytes,16,opt,name=baseFee,proto3" json:"baseFee,omitempty"` +} + +func (x *Header) Reset() { + *x = Header{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_lightclients_eth_v1_eth_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Header) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Header) ProtoMessage() {} + +// Deprecated: Use Header.ProtoReflect.Descriptor instead. +func (*Header) Descriptor() ([]byte, []int) { + return file_tibc_lightclients_eth_v1_eth_proto_rawDescGZIP(), []int{0} +} + +func (x *Header) GetParentHash() []byte { + if x != nil { + return x.ParentHash + } + return nil +} + +func (x *Header) GetUncleHash() []byte { + if x != nil { + return x.UncleHash + } + return nil +} + +func (x *Header) GetCoinbase() []byte { + if x != nil { + return x.Coinbase + } + return nil +} + +func (x *Header) GetRoot() []byte { + if x != nil { + return x.Root + } + return nil +} + +func (x *Header) GetTxHash() []byte { + if x != nil { + return x.TxHash + } + return nil +} + +func (x *Header) GetReceiptHash() []byte { + if x != nil { + return x.ReceiptHash + } + return nil +} + +func (x *Header) GetBloom() []byte { + if x != nil { + return x.Bloom + } + return nil +} + +func (x *Header) GetDifficulty() string { + if x != nil { + return x.Difficulty + } + return "" +} + +func (x *Header) GetHeight() *v1.Height { + if x != nil { + return x.Height + } + return nil +} + +func (x *Header) GetGasLimit() uint64 { + if x != nil { + return x.GasLimit + } + return 0 +} + +func (x *Header) GetGasUsed() uint64 { + if x != nil { + return x.GasUsed + } + return 0 +} + +func (x *Header) GetTime() uint64 { + if x != nil { + return x.Time + } + return 0 +} + +func (x *Header) GetExtra() []byte { + if x != nil { + return x.Extra + } + return nil +} + +func (x *Header) GetMixDigest() []byte { + if x != nil { + return x.MixDigest + } + return nil +} + +func (x *Header) GetNonce() uint64 { + if x != nil { + return x.Nonce + } + return 0 +} + +func (x *Header) GetBaseFee() string { + if x != nil { + return x.BaseFee + } + return "" +} + +// ClientState from eth tracks the current validator set, latest height, +// and a possible frozen height. +type ClientState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Header *Header `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + ChainId uint64 `protobuf:"varint,2,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + ContractAddress []byte `protobuf:"bytes,3,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"` + TrustingPeriod uint64 `protobuf:"varint,4,opt,name=trusting_period,json=trustingPeriod,proto3" json:"trusting_period,omitempty"` + TimeDelay uint64 `protobuf:"varint,5,opt,name=timeDelay,proto3" json:"timeDelay,omitempty"` + BlockDelay uint64 `protobuf:"varint,6,opt,name=blockDelay,proto3" json:"blockDelay,omitempty"` +} + +func (x *ClientState) Reset() { + *x = ClientState{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_lightclients_eth_v1_eth_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ClientState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ClientState) ProtoMessage() {} + +// Deprecated: Use ClientState.ProtoReflect.Descriptor instead. +func (*ClientState) Descriptor() ([]byte, []int) { + return file_tibc_lightclients_eth_v1_eth_proto_rawDescGZIP(), []int{1} +} + +func (x *ClientState) GetHeader() *Header { + if x != nil { + return x.Header + } + return nil +} + +func (x *ClientState) GetChainId() uint64 { + if x != nil { + return x.ChainId + } + return 0 +} + +func (x *ClientState) GetContractAddress() []byte { + if x != nil { + return x.ContractAddress + } + return nil +} + +func (x *ClientState) GetTrustingPeriod() uint64 { + if x != nil { + return x.TrustingPeriod + } + return 0 +} + +func (x *ClientState) GetTimeDelay() uint64 { + if x != nil { + return x.TimeDelay + } + return 0 +} + +func (x *ClientState) GetBlockDelay() uint64 { + if x != nil { + return x.BlockDelay + } + return 0 +} + +// ConsensusState defines the consensus state from eth. +type ConsensusState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // timestamp that corresponds to the block height in which the ConsensusState + // was stored. + Timestamp uint64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + Number *v1.Height `protobuf:"bytes,2,opt,name=number,proto3" json:"number,omitempty"` + Root []byte `protobuf:"bytes,3,opt,name=root,proto3" json:"root,omitempty"` +} + +func (x *ConsensusState) Reset() { + *x = ConsensusState{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_lightclients_eth_v1_eth_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ConsensusState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ConsensusState) ProtoMessage() {} + +// Deprecated: Use ConsensusState.ProtoReflect.Descriptor instead. +func (*ConsensusState) Descriptor() ([]byte, []int) { + return file_tibc_lightclients_eth_v1_eth_proto_rawDescGZIP(), []int{2} +} + +func (x *ConsensusState) GetTimestamp() uint64 { + if x != nil { + return x.Timestamp + } + return 0 +} + +func (x *ConsensusState) GetNumber() *v1.Height { + if x != nil { + return x.Number + } + return nil +} + +func (x *ConsensusState) GetRoot() []byte { + if x != nil { + return x.Root + } + return nil +} + +type StorageResult struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + Proof []string `protobuf:"bytes,3,rep,name=proof,proto3" json:"proof,omitempty"` +} + +func (x *StorageResult) Reset() { + *x = StorageResult{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_lightclients_eth_v1_eth_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *StorageResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StorageResult) ProtoMessage() {} + +// Deprecated: Use StorageResult.ProtoReflect.Descriptor instead. +func (*StorageResult) Descriptor() ([]byte, []int) { + return file_tibc_lightclients_eth_v1_eth_proto_rawDescGZIP(), []int{3} +} + +func (x *StorageResult) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *StorageResult) GetValue() string { + if x != nil { + return x.Value + } + return "" +} + +func (x *StorageResult) GetProof() []string { + if x != nil { + return x.Proof + } + return nil +} + +type Proof struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + Balance string `protobuf:"bytes,2,opt,name=balance,proto3" json:"balance,omitempty"` + CodeHash string `protobuf:"bytes,3,opt,name=code_hash,json=codeHash,proto3" json:"code_hash,omitempty"` + Nonce string `protobuf:"bytes,4,opt,name=nonce,proto3" json:"nonce,omitempty"` + StorageHash string `protobuf:"bytes,5,opt,name=storage_hash,json=storageHash,proto3" json:"storage_hash,omitempty"` + AccountProof []string `protobuf:"bytes,6,rep,name=account_proof,json=accountProof,proto3" json:"account_proof,omitempty"` + StorageProof []*StorageResult `protobuf:"bytes,7,rep,name=storage_proof,json=storageProof,proto3" json:"storage_proof,omitempty"` +} + +func (x *Proof) Reset() { + *x = Proof{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_lightclients_eth_v1_eth_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Proof) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Proof) ProtoMessage() {} + +// Deprecated: Use Proof.ProtoReflect.Descriptor instead. +func (*Proof) Descriptor() ([]byte, []int) { + return file_tibc_lightclients_eth_v1_eth_proto_rawDescGZIP(), []int{4} +} + +func (x *Proof) GetAddress() string { + if x != nil { + return x.Address + } + return "" +} + +func (x *Proof) GetBalance() string { + if x != nil { + return x.Balance + } + return "" +} + +func (x *Proof) GetCodeHash() string { + if x != nil { + return x.CodeHash + } + return "" +} + +func (x *Proof) GetNonce() string { + if x != nil { + return x.Nonce + } + return "" +} + +func (x *Proof) GetStorageHash() string { + if x != nil { + return x.StorageHash + } + return "" +} + +func (x *Proof) GetAccountProof() []string { + if x != nil { + return x.AccountProof + } + return nil +} + +func (x *Proof) GetStorageProof() []*StorageResult { + if x != nil { + return x.StorageProof + } + return nil +} + +var File_tibc_lightclients_eth_v1_eth_proto protoreflect.FileDescriptor + +var file_tibc_lightclients_eth_v1_eth_proto_rawDesc = []byte{ + 0x0a, 0x22, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x73, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x65, 0x74, 0x68, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x18, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x6c, 0x69, 0x67, 0x68, 0x74, + 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x1a, 0x14, + 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, + 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xdc, 0x03, 0x0a, 0x06, 0x48, 0x65, 0x61, 0x64, 0x65, + 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, + 0x73, 0x68, 0x12, 0x1d, 0x0a, 0x0a, 0x75, 0x6e, 0x63, 0x6c, 0x65, 0x5f, 0x68, 0x61, 0x73, 0x68, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x75, 0x6e, 0x63, 0x6c, 0x65, 0x48, 0x61, 0x73, + 0x68, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x6f, 0x69, 0x6e, 0x62, 0x61, 0x73, 0x65, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x08, 0x63, 0x6f, 0x69, 0x6e, 0x62, 0x61, 0x73, 0x65, 0x12, 0x12, 0x0a, + 0x04, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x72, 0x6f, 0x6f, + 0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x78, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x0c, 0x52, 0x06, 0x74, 0x78, 0x48, 0x61, 0x73, 0x68, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x65, + 0x63, 0x65, 0x69, 0x70, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x0b, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x14, 0x0a, + 0x05, 0x62, 0x6c, 0x6f, 0x6f, 0x6d, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x62, 0x6c, + 0x6f, 0x6f, 0x6d, 0x12, 0x1e, 0x0a, 0x0a, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, + 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, + 0x6c, 0x74, 0x79, 0x12, 0x39, 0x0a, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x09, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, + 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1b, + 0x0a, 0x09, 0x67, 0x61, 0x73, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, + 0x04, 0x52, 0x08, 0x67, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x67, + 0x61, 0x73, 0x5f, 0x75, 0x73, 0x65, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x67, + 0x61, 0x73, 0x55, 0x73, 0x65, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0c, + 0x20, 0x01, 0x28, 0x04, 0x52, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x78, + 0x74, 0x72, 0x61, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x65, 0x78, 0x74, 0x72, 0x61, + 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x69, 0x78, 0x5f, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x18, 0x0e, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x6d, 0x69, 0x78, 0x44, 0x69, 0x67, 0x65, 0x73, 0x74, 0x12, + 0x14, 0x0a, 0x05, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, + 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, + 0x18, 0x10, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x3a, + 0x04, 0x88, 0xa0, 0x1f, 0x00, 0x22, 0x80, 0x02, 0x0a, 0x0b, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x3e, 0x0a, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x6c, 0x69, 0x67, + 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, + 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x06, 0x68, + 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x19, 0x0a, 0x08, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x69, + 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, + 0x12, 0x29, 0x0a, 0x10, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x5f, 0x61, 0x64, 0x64, + 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x63, 0x6f, 0x6e, 0x74, + 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x74, + 0x72, 0x75, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x74, 0x72, 0x75, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x65, + 0x72, 0x69, 0x6f, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x44, 0x65, 0x6c, 0x61, + 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x44, 0x65, 0x6c, + 0x61, 0x79, 0x12, 0x1e, 0x0a, 0x0a, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x44, 0x65, 0x6c, 0x61, 0x79, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x44, 0x65, 0x6c, + 0x61, 0x79, 0x3a, 0x04, 0x88, 0xa0, 0x1f, 0x00, 0x22, 0x83, 0x01, 0x0a, 0x0e, 0x43, 0x6f, 0x6e, + 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x74, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, + 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x39, 0x0a, 0x06, 0x6e, 0x75, 0x6d, + 0x62, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x74, 0x69, 0x62, 0x63, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, + 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x06, 0x6e, 0x75, + 0x6d, 0x62, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0c, 0x52, 0x04, 0x72, 0x6f, 0x6f, 0x74, 0x3a, 0x04, 0x88, 0xa0, 0x1f, 0x00, 0x22, 0x53, + 0x0a, 0x0d, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, + 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, + 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x6f, 0x6f, 0x66, + 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x3a, 0x04, 0x88, + 0xa0, 0x1f, 0x00, 0x22, 0x8a, 0x02, 0x0a, 0x05, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x18, 0x0a, + 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, + 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, + 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x6f, 0x64, 0x65, 0x48, 0x61, 0x73, 0x68, 0x12, 0x14, + 0x0a, 0x05, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6e, + 0x6f, 0x6e, 0x63, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, + 0x68, 0x61, 0x73, 0x68, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x74, 0x6f, 0x72, + 0x61, 0x67, 0x65, 0x48, 0x61, 0x73, 0x68, 0x12, 0x23, 0x0a, 0x0d, 0x61, 0x63, 0x63, 0x6f, 0x75, + 0x6e, 0x74, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, + 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x4c, 0x0a, 0x0d, + 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x07, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x6c, 0x69, 0x67, 0x68, 0x74, + 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, + 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x0c, 0x73, 0x74, + 0x6f, 0x72, 0x61, 0x67, 0x65, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x3a, 0x04, 0x88, 0xa0, 0x1f, 0x00, + 0x42, 0xec, 0x01, 0x0a, 0x1c, 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x6c, 0x69, + 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, + 0x31, 0x42, 0x08, 0x45, 0x74, 0x68, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3f, 0x67, + 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, + 0x65, 0x61, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2d, 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x74, 0x69, 0x62, 0x63, 0x2f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x73, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x3b, 0x65, 0x74, 0x68, 0x76, 0x31, 0xa2, 0x02, + 0x03, 0x54, 0x4c, 0x45, 0xaa, 0x02, 0x18, 0x54, 0x69, 0x62, 0x63, 0x2e, 0x4c, 0x69, 0x67, 0x68, + 0x74, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x45, 0x74, 0x68, 0x2e, 0x56, 0x31, 0xca, + 0x02, 0x18, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x73, 0x5c, 0x45, 0x74, 0x68, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x24, 0x54, 0x69, 0x62, + 0x63, 0x5c, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x5c, 0x45, + 0x74, 0x68, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0xea, 0x02, 0x1b, 0x54, 0x69, 0x62, 0x63, 0x3a, 0x3a, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x63, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x3a, 0x3a, 0x45, 0x74, 0x68, 0x3a, 0x3a, 0x56, 0x31, 0x62, + 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_lightclients_eth_v1_eth_proto_rawDescOnce sync.Once + file_tibc_lightclients_eth_v1_eth_proto_rawDescData = file_tibc_lightclients_eth_v1_eth_proto_rawDesc +) + +func file_tibc_lightclients_eth_v1_eth_proto_rawDescGZIP() []byte { + file_tibc_lightclients_eth_v1_eth_proto_rawDescOnce.Do(func() { + file_tibc_lightclients_eth_v1_eth_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_lightclients_eth_v1_eth_proto_rawDescData) + }) + return file_tibc_lightclients_eth_v1_eth_proto_rawDescData +} + +var file_tibc_lightclients_eth_v1_eth_proto_msgTypes = make([]protoimpl.MessageInfo, 5) +var file_tibc_lightclients_eth_v1_eth_proto_goTypes = []interface{}{ + (*Header)(nil), // 0: tibc.lightclients.eth.v1.Header + (*ClientState)(nil), // 1: tibc.lightclients.eth.v1.ClientState + (*ConsensusState)(nil), // 2: tibc.lightclients.eth.v1.ConsensusState + (*StorageResult)(nil), // 3: tibc.lightclients.eth.v1.StorageResult + (*Proof)(nil), // 4: tibc.lightclients.eth.v1.Proof + (*v1.Height)(nil), // 5: tibc.core.client.v1.Height +} +var file_tibc_lightclients_eth_v1_eth_proto_depIdxs = []int32{ + 5, // 0: tibc.lightclients.eth.v1.Header.height:type_name -> tibc.core.client.v1.Height + 0, // 1: tibc.lightclients.eth.v1.ClientState.header:type_name -> tibc.lightclients.eth.v1.Header + 5, // 2: tibc.lightclients.eth.v1.ConsensusState.number:type_name -> tibc.core.client.v1.Height + 3, // 3: tibc.lightclients.eth.v1.Proof.storage_proof:type_name -> tibc.lightclients.eth.v1.StorageResult + 4, // [4:4] is the sub-list for method output_type + 4, // [4:4] is the sub-list for method input_type + 4, // [4:4] is the sub-list for extension type_name + 4, // [4:4] is the sub-list for extension extendee + 0, // [0:4] is the sub-list for field type_name +} + +func init() { file_tibc_lightclients_eth_v1_eth_proto_init() } +func file_tibc_lightclients_eth_v1_eth_proto_init() { + if File_tibc_lightclients_eth_v1_eth_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_tibc_lightclients_eth_v1_eth_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Header); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_lightclients_eth_v1_eth_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ClientState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_lightclients_eth_v1_eth_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ConsensusState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_lightclients_eth_v1_eth_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*StorageResult); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_lightclients_eth_v1_eth_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Proof); 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_tibc_lightclients_eth_v1_eth_proto_rawDesc, + NumEnums: 0, + NumMessages: 5, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_tibc_lightclients_eth_v1_eth_proto_goTypes, + DependencyIndexes: file_tibc_lightclients_eth_v1_eth_proto_depIdxs, + MessageInfos: file_tibc_lightclients_eth_v1_eth_proto_msgTypes, + }.Build() + File_tibc_lightclients_eth_v1_eth_proto = out.File + file_tibc_lightclients_eth_v1_eth_proto_rawDesc = nil + file_tibc_lightclients_eth_v1_eth_proto_goTypes = nil + file_tibc_lightclients_eth_v1_eth_proto_depIdxs = nil +} diff --git a/api/tibc/lightclients/tendermint/v1/tendermint.pulsar.go b/api/tibc/lightclients/tendermint/v1/tendermint.pulsar.go new file mode 100644 index 00000000..a7e29ae5 --- /dev/null +++ b/api/tibc/lightclients/tendermint/v1/tendermint.pulsar.go @@ -0,0 +1,3344 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package tendermintv1 + +import ( + types "cosmossdk.io/api/tendermint/types" + fmt "fmt" + v1 "github.com/bianjieai/tibc-go/api/tibc/core/client/v1" + v11 "github.com/bianjieai/tibc-go/api/tibc/core/commitment/v1" + runtime "github.com/cosmos/cosmos-proto/runtime" + _ "github.com/cosmos/gogoproto/gogoproto" + _go "github.com/cosmos/ics23/go" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoiface "google.golang.org/protobuf/runtime/protoiface" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + durationpb "google.golang.org/protobuf/types/known/durationpb" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + io "io" + reflect "reflect" + sync "sync" +) + +var _ protoreflect.List = (*_ClientState_7_list)(nil) + +type _ClientState_7_list struct { + list *[]*_go.ProofSpec +} + +func (x *_ClientState_7_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_ClientState_7_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_ClientState_7_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*_go.ProofSpec) + (*x.list)[i] = concreteValue +} + +func (x *_ClientState_7_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*_go.ProofSpec) + *x.list = append(*x.list, concreteValue) +} + +func (x *_ClientState_7_list) AppendMutable() protoreflect.Value { + v := new(_go.ProofSpec) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_ClientState_7_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_ClientState_7_list) NewElement() protoreflect.Value { + v := new(_go.ProofSpec) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_ClientState_7_list) IsValid() bool { + return x.list != nil +} + +var ( + md_ClientState protoreflect.MessageDescriptor + fd_ClientState_chain_id protoreflect.FieldDescriptor + fd_ClientState_trust_level protoreflect.FieldDescriptor + fd_ClientState_trusting_period protoreflect.FieldDescriptor + fd_ClientState_unbonding_period protoreflect.FieldDescriptor + fd_ClientState_max_clock_drift protoreflect.FieldDescriptor + fd_ClientState_latest_height protoreflect.FieldDescriptor + fd_ClientState_proof_specs protoreflect.FieldDescriptor + fd_ClientState_merkle_prefix protoreflect.FieldDescriptor + fd_ClientState_time_delay protoreflect.FieldDescriptor +) + +func init() { + file_tibc_lightclients_tendermint_v1_tendermint_proto_init() + md_ClientState = File_tibc_lightclients_tendermint_v1_tendermint_proto.Messages().ByName("ClientState") + fd_ClientState_chain_id = md_ClientState.Fields().ByName("chain_id") + fd_ClientState_trust_level = md_ClientState.Fields().ByName("trust_level") + fd_ClientState_trusting_period = md_ClientState.Fields().ByName("trusting_period") + fd_ClientState_unbonding_period = md_ClientState.Fields().ByName("unbonding_period") + fd_ClientState_max_clock_drift = md_ClientState.Fields().ByName("max_clock_drift") + fd_ClientState_latest_height = md_ClientState.Fields().ByName("latest_height") + fd_ClientState_proof_specs = md_ClientState.Fields().ByName("proof_specs") + fd_ClientState_merkle_prefix = md_ClientState.Fields().ByName("merkle_prefix") + fd_ClientState_time_delay = md_ClientState.Fields().ByName("time_delay") +} + +var _ protoreflect.Message = (*fastReflection_ClientState)(nil) + +type fastReflection_ClientState ClientState + +func (x *ClientState) ProtoReflect() protoreflect.Message { + return (*fastReflection_ClientState)(x) +} + +func (x *ClientState) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_lightclients_tendermint_v1_tendermint_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_ClientState_messageType fastReflection_ClientState_messageType +var _ protoreflect.MessageType = fastReflection_ClientState_messageType{} + +type fastReflection_ClientState_messageType struct{} + +func (x fastReflection_ClientState_messageType) Zero() protoreflect.Message { + return (*fastReflection_ClientState)(nil) +} +func (x fastReflection_ClientState_messageType) New() protoreflect.Message { + return new(fastReflection_ClientState) +} +func (x fastReflection_ClientState_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_ClientState +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_ClientState) Descriptor() protoreflect.MessageDescriptor { + return md_ClientState +} + +// 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_ClientState) Type() protoreflect.MessageType { + return _fastReflection_ClientState_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_ClientState) New() protoreflect.Message { + return new(fastReflection_ClientState) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_ClientState) Interface() protoreflect.ProtoMessage { + return (*ClientState)(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_ClientState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ChainId != "" { + value := protoreflect.ValueOfString(x.ChainId) + if !f(fd_ClientState_chain_id, value) { + return + } + } + if x.TrustLevel != nil { + value := protoreflect.ValueOfMessage(x.TrustLevel.ProtoReflect()) + if !f(fd_ClientState_trust_level, value) { + return + } + } + if x.TrustingPeriod != nil { + value := protoreflect.ValueOfMessage(x.TrustingPeriod.ProtoReflect()) + if !f(fd_ClientState_trusting_period, value) { + return + } + } + if x.UnbondingPeriod != nil { + value := protoreflect.ValueOfMessage(x.UnbondingPeriod.ProtoReflect()) + if !f(fd_ClientState_unbonding_period, value) { + return + } + } + if x.MaxClockDrift != nil { + value := protoreflect.ValueOfMessage(x.MaxClockDrift.ProtoReflect()) + if !f(fd_ClientState_max_clock_drift, value) { + return + } + } + if x.LatestHeight != nil { + value := protoreflect.ValueOfMessage(x.LatestHeight.ProtoReflect()) + if !f(fd_ClientState_latest_height, value) { + return + } + } + if len(x.ProofSpecs) != 0 { + value := protoreflect.ValueOfList(&_ClientState_7_list{list: &x.ProofSpecs}) + if !f(fd_ClientState_proof_specs, value) { + return + } + } + if x.MerklePrefix != nil { + value := protoreflect.ValueOfMessage(x.MerklePrefix.ProtoReflect()) + if !f(fd_ClientState_merkle_prefix, value) { + return + } + } + if x.TimeDelay != uint64(0) { + value := protoreflect.ValueOfUint64(x.TimeDelay) + if !f(fd_ClientState_time_delay, 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_ClientState) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.lightclients.tendermint.v1.ClientState.chain_id": + return x.ChainId != "" + case "tibc.lightclients.tendermint.v1.ClientState.trust_level": + return x.TrustLevel != nil + case "tibc.lightclients.tendermint.v1.ClientState.trusting_period": + return x.TrustingPeriod != nil + case "tibc.lightclients.tendermint.v1.ClientState.unbonding_period": + return x.UnbondingPeriod != nil + case "tibc.lightclients.tendermint.v1.ClientState.max_clock_drift": + return x.MaxClockDrift != nil + case "tibc.lightclients.tendermint.v1.ClientState.latest_height": + return x.LatestHeight != nil + case "tibc.lightclients.tendermint.v1.ClientState.proof_specs": + return len(x.ProofSpecs) != 0 + case "tibc.lightclients.tendermint.v1.ClientState.merkle_prefix": + return x.MerklePrefix != nil + case "tibc.lightclients.tendermint.v1.ClientState.time_delay": + return x.TimeDelay != uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.ClientState")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.ClientState 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_ClientState) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.lightclients.tendermint.v1.ClientState.chain_id": + x.ChainId = "" + case "tibc.lightclients.tendermint.v1.ClientState.trust_level": + x.TrustLevel = nil + case "tibc.lightclients.tendermint.v1.ClientState.trusting_period": + x.TrustingPeriod = nil + case "tibc.lightclients.tendermint.v1.ClientState.unbonding_period": + x.UnbondingPeriod = nil + case "tibc.lightclients.tendermint.v1.ClientState.max_clock_drift": + x.MaxClockDrift = nil + case "tibc.lightclients.tendermint.v1.ClientState.latest_height": + x.LatestHeight = nil + case "tibc.lightclients.tendermint.v1.ClientState.proof_specs": + x.ProofSpecs = nil + case "tibc.lightclients.tendermint.v1.ClientState.merkle_prefix": + x.MerklePrefix = nil + case "tibc.lightclients.tendermint.v1.ClientState.time_delay": + x.TimeDelay = uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.ClientState")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.ClientState 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_ClientState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.lightclients.tendermint.v1.ClientState.chain_id": + value := x.ChainId + return protoreflect.ValueOfString(value) + case "tibc.lightclients.tendermint.v1.ClientState.trust_level": + value := x.TrustLevel + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ClientState.trusting_period": + value := x.TrustingPeriod + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ClientState.unbonding_period": + value := x.UnbondingPeriod + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ClientState.max_clock_drift": + value := x.MaxClockDrift + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ClientState.latest_height": + value := x.LatestHeight + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ClientState.proof_specs": + if len(x.ProofSpecs) == 0 { + return protoreflect.ValueOfList(&_ClientState_7_list{}) + } + listValue := &_ClientState_7_list{list: &x.ProofSpecs} + return protoreflect.ValueOfList(listValue) + case "tibc.lightclients.tendermint.v1.ClientState.merkle_prefix": + value := x.MerklePrefix + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ClientState.time_delay": + value := x.TimeDelay + return protoreflect.ValueOfUint64(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.ClientState")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.ClientState 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_ClientState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.lightclients.tendermint.v1.ClientState.chain_id": + x.ChainId = value.Interface().(string) + case "tibc.lightclients.tendermint.v1.ClientState.trust_level": + x.TrustLevel = value.Message().Interface().(*Fraction) + case "tibc.lightclients.tendermint.v1.ClientState.trusting_period": + x.TrustingPeriod = value.Message().Interface().(*durationpb.Duration) + case "tibc.lightclients.tendermint.v1.ClientState.unbonding_period": + x.UnbondingPeriod = value.Message().Interface().(*durationpb.Duration) + case "tibc.lightclients.tendermint.v1.ClientState.max_clock_drift": + x.MaxClockDrift = value.Message().Interface().(*durationpb.Duration) + case "tibc.lightclients.tendermint.v1.ClientState.latest_height": + x.LatestHeight = value.Message().Interface().(*v1.Height) + case "tibc.lightclients.tendermint.v1.ClientState.proof_specs": + lv := value.List() + clv := lv.(*_ClientState_7_list) + x.ProofSpecs = *clv.list + case "tibc.lightclients.tendermint.v1.ClientState.merkle_prefix": + x.MerklePrefix = value.Message().Interface().(*v11.MerklePrefix) + case "tibc.lightclients.tendermint.v1.ClientState.time_delay": + x.TimeDelay = value.Uint() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.ClientState")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.ClientState 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_ClientState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.tendermint.v1.ClientState.trust_level": + if x.TrustLevel == nil { + x.TrustLevel = new(Fraction) + } + return protoreflect.ValueOfMessage(x.TrustLevel.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ClientState.trusting_period": + if x.TrustingPeriod == nil { + x.TrustingPeriod = new(durationpb.Duration) + } + return protoreflect.ValueOfMessage(x.TrustingPeriod.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ClientState.unbonding_period": + if x.UnbondingPeriod == nil { + x.UnbondingPeriod = new(durationpb.Duration) + } + return protoreflect.ValueOfMessage(x.UnbondingPeriod.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ClientState.max_clock_drift": + if x.MaxClockDrift == nil { + x.MaxClockDrift = new(durationpb.Duration) + } + return protoreflect.ValueOfMessage(x.MaxClockDrift.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ClientState.latest_height": + if x.LatestHeight == nil { + x.LatestHeight = new(v1.Height) + } + return protoreflect.ValueOfMessage(x.LatestHeight.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ClientState.proof_specs": + if x.ProofSpecs == nil { + x.ProofSpecs = []*_go.ProofSpec{} + } + value := &_ClientState_7_list{list: &x.ProofSpecs} + return protoreflect.ValueOfList(value) + case "tibc.lightclients.tendermint.v1.ClientState.merkle_prefix": + if x.MerklePrefix == nil { + x.MerklePrefix = new(v11.MerklePrefix) + } + return protoreflect.ValueOfMessage(x.MerklePrefix.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ClientState.chain_id": + panic(fmt.Errorf("field chain_id of message tibc.lightclients.tendermint.v1.ClientState is not mutable")) + case "tibc.lightclients.tendermint.v1.ClientState.time_delay": + panic(fmt.Errorf("field time_delay of message tibc.lightclients.tendermint.v1.ClientState is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.ClientState")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.ClientState 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_ClientState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.tendermint.v1.ClientState.chain_id": + return protoreflect.ValueOfString("") + case "tibc.lightclients.tendermint.v1.ClientState.trust_level": + m := new(Fraction) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ClientState.trusting_period": + m := new(durationpb.Duration) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ClientState.unbonding_period": + m := new(durationpb.Duration) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ClientState.max_clock_drift": + m := new(durationpb.Duration) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ClientState.latest_height": + m := new(v1.Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ClientState.proof_specs": + list := []*_go.ProofSpec{} + return protoreflect.ValueOfList(&_ClientState_7_list{list: &list}) + case "tibc.lightclients.tendermint.v1.ClientState.merkle_prefix": + m := new(v11.MerklePrefix) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ClientState.time_delay": + return protoreflect.ValueOfUint64(uint64(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.ClientState")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.ClientState 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_ClientState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.lightclients.tendermint.v1.ClientState", 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_ClientState) 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_ClientState) 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_ClientState) 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_ClientState) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*ClientState) + 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.ChainId) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.TrustLevel != nil { + l = options.Size(x.TrustLevel) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.TrustingPeriod != nil { + l = options.Size(x.TrustingPeriod) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.UnbondingPeriod != nil { + l = options.Size(x.UnbondingPeriod) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.MaxClockDrift != nil { + l = options.Size(x.MaxClockDrift) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.LatestHeight != nil { + l = options.Size(x.LatestHeight) + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.ProofSpecs) > 0 { + for _, e := range x.ProofSpecs { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.MerklePrefix != nil { + l = options.Size(x.MerklePrefix) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.TimeDelay != 0 { + n += 1 + runtime.Sov(uint64(x.TimeDelay)) + } + 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().(*ClientState) + 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.TimeDelay != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.TimeDelay)) + i-- + dAtA[i] = 0x48 + } + if x.MerklePrefix != nil { + encoded, err := options.Marshal(x.MerklePrefix) + 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] = 0x42 + } + if len(x.ProofSpecs) > 0 { + for iNdEx := len(x.ProofSpecs) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.ProofSpecs[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] = 0x3a + } + } + if x.LatestHeight != nil { + encoded, err := options.Marshal(x.LatestHeight) + 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] = 0x32 + } + if x.MaxClockDrift != nil { + encoded, err := options.Marshal(x.MaxClockDrift) + 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] = 0x2a + } + if x.UnbondingPeriod != nil { + encoded, err := options.Marshal(x.UnbondingPeriod) + 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] = 0x22 + } + if x.TrustingPeriod != nil { + encoded, err := options.Marshal(x.TrustingPeriod) + 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.TrustLevel != nil { + encoded, err := options.Marshal(x.TrustLevel) + 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.ChainId) > 0 { + i -= len(x.ChainId) + copy(dAtA[i:], x.ChainId) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainId))) + 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().(*ClientState) + 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: ClientState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ClientState: 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 ChainId", 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.ChainId = 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 TrustLevel", 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.TrustLevel == nil { + x.TrustLevel = &Fraction{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TrustLevel); 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 TrustingPeriod", 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.TrustingPeriod == nil { + x.TrustingPeriod = &durationpb.Duration{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TrustingPeriod); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UnbondingPeriod", 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.UnbondingPeriod == nil { + x.UnbondingPeriod = &durationpb.Duration{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.UnbondingPeriod); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MaxClockDrift", 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.MaxClockDrift == nil { + x.MaxClockDrift = &durationpb.Duration{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.MaxClockDrift); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field LatestHeight", 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.LatestHeight == nil { + x.LatestHeight = &v1.Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.LatestHeight); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProofSpecs", 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.ProofSpecs = append(x.ProofSpecs, &_go.ProofSpec{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ProofSpecs[len(x.ProofSpecs)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MerklePrefix", 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.MerklePrefix == nil { + x.MerklePrefix = &v11.MerklePrefix{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.MerklePrefix); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 9: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TimeDelay", wireType) + } + x.TimeDelay = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.TimeDelay |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_ConsensusState protoreflect.MessageDescriptor + fd_ConsensusState_timestamp protoreflect.FieldDescriptor + fd_ConsensusState_root protoreflect.FieldDescriptor + fd_ConsensusState_next_validators_hash protoreflect.FieldDescriptor +) + +func init() { + file_tibc_lightclients_tendermint_v1_tendermint_proto_init() + md_ConsensusState = File_tibc_lightclients_tendermint_v1_tendermint_proto.Messages().ByName("ConsensusState") + fd_ConsensusState_timestamp = md_ConsensusState.Fields().ByName("timestamp") + fd_ConsensusState_root = md_ConsensusState.Fields().ByName("root") + fd_ConsensusState_next_validators_hash = md_ConsensusState.Fields().ByName("next_validators_hash") +} + +var _ protoreflect.Message = (*fastReflection_ConsensusState)(nil) + +type fastReflection_ConsensusState ConsensusState + +func (x *ConsensusState) ProtoReflect() protoreflect.Message { + return (*fastReflection_ConsensusState)(x) +} + +func (x *ConsensusState) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_lightclients_tendermint_v1_tendermint_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_ConsensusState_messageType fastReflection_ConsensusState_messageType +var _ protoreflect.MessageType = fastReflection_ConsensusState_messageType{} + +type fastReflection_ConsensusState_messageType struct{} + +func (x fastReflection_ConsensusState_messageType) Zero() protoreflect.Message { + return (*fastReflection_ConsensusState)(nil) +} +func (x fastReflection_ConsensusState_messageType) New() protoreflect.Message { + return new(fastReflection_ConsensusState) +} +func (x fastReflection_ConsensusState_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_ConsensusState +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_ConsensusState) Descriptor() protoreflect.MessageDescriptor { + return md_ConsensusState +} + +// 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_ConsensusState) Type() protoreflect.MessageType { + return _fastReflection_ConsensusState_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_ConsensusState) New() protoreflect.Message { + return new(fastReflection_ConsensusState) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_ConsensusState) Interface() protoreflect.ProtoMessage { + return (*ConsensusState)(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_ConsensusState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Timestamp != nil { + value := protoreflect.ValueOfMessage(x.Timestamp.ProtoReflect()) + if !f(fd_ConsensusState_timestamp, value) { + return + } + } + if x.Root != nil { + value := protoreflect.ValueOfMessage(x.Root.ProtoReflect()) + if !f(fd_ConsensusState_root, value) { + return + } + } + if len(x.NextValidatorsHash) != 0 { + value := protoreflect.ValueOfBytes(x.NextValidatorsHash) + if !f(fd_ConsensusState_next_validators_hash, 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_ConsensusState) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.lightclients.tendermint.v1.ConsensusState.timestamp": + return x.Timestamp != nil + case "tibc.lightclients.tendermint.v1.ConsensusState.root": + return x.Root != nil + case "tibc.lightclients.tendermint.v1.ConsensusState.next_validators_hash": + return len(x.NextValidatorsHash) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.ConsensusState")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.ConsensusState 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_ConsensusState) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.lightclients.tendermint.v1.ConsensusState.timestamp": + x.Timestamp = nil + case "tibc.lightclients.tendermint.v1.ConsensusState.root": + x.Root = nil + case "tibc.lightclients.tendermint.v1.ConsensusState.next_validators_hash": + x.NextValidatorsHash = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.ConsensusState")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.ConsensusState 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_ConsensusState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.lightclients.tendermint.v1.ConsensusState.timestamp": + value := x.Timestamp + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ConsensusState.root": + value := x.Root + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ConsensusState.next_validators_hash": + value := x.NextValidatorsHash + return protoreflect.ValueOfBytes(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.ConsensusState")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.ConsensusState 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_ConsensusState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.lightclients.tendermint.v1.ConsensusState.timestamp": + x.Timestamp = value.Message().Interface().(*timestamppb.Timestamp) + case "tibc.lightclients.tendermint.v1.ConsensusState.root": + x.Root = value.Message().Interface().(*v11.MerkleRoot) + case "tibc.lightclients.tendermint.v1.ConsensusState.next_validators_hash": + x.NextValidatorsHash = value.Bytes() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.ConsensusState")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.ConsensusState 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_ConsensusState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.tendermint.v1.ConsensusState.timestamp": + if x.Timestamp == nil { + x.Timestamp = new(timestamppb.Timestamp) + } + return protoreflect.ValueOfMessage(x.Timestamp.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ConsensusState.root": + if x.Root == nil { + x.Root = new(v11.MerkleRoot) + } + return protoreflect.ValueOfMessage(x.Root.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ConsensusState.next_validators_hash": + panic(fmt.Errorf("field next_validators_hash of message tibc.lightclients.tendermint.v1.ConsensusState is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.ConsensusState")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.ConsensusState 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_ConsensusState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.tendermint.v1.ConsensusState.timestamp": + m := new(timestamppb.Timestamp) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ConsensusState.root": + m := new(v11.MerkleRoot) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.ConsensusState.next_validators_hash": + return protoreflect.ValueOfBytes(nil) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.ConsensusState")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.ConsensusState 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_ConsensusState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.lightclients.tendermint.v1.ConsensusState", 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_ConsensusState) 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_ConsensusState) 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_ConsensusState) 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_ConsensusState) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*ConsensusState) + 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.Timestamp != nil { + l = options.Size(x.Timestamp) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Root != nil { + l = options.Size(x.Root) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.NextValidatorsHash) + 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().(*ConsensusState) + 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.NextValidatorsHash) > 0 { + i -= len(x.NextValidatorsHash) + copy(dAtA[i:], x.NextValidatorsHash) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NextValidatorsHash))) + i-- + dAtA[i] = 0x1a + } + if x.Root != nil { + encoded, err := options.Marshal(x.Root) + 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 x.Timestamp != nil { + encoded, err := options.Marshal(x.Timestamp) + 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().(*ConsensusState) + 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: ConsensusState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ConsensusState: 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 Timestamp", 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.Timestamp == nil { + x.Timestamp = ×tamppb.Timestamp{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Timestamp); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Root", 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.Root == nil { + x.Root = &v11.MerkleRoot{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Root); 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 NextValidatorsHash", wireType) + } + var byteLen 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++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + 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.NextValidatorsHash = append(x.NextValidatorsHash[:0], dAtA[iNdEx:postIndex]...) + if x.NextValidatorsHash == nil { + x.NextValidatorsHash = []byte{} + } + 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_Header protoreflect.MessageDescriptor + fd_Header_signed_header protoreflect.FieldDescriptor + fd_Header_validator_set protoreflect.FieldDescriptor + fd_Header_trusted_height protoreflect.FieldDescriptor + fd_Header_trusted_validators protoreflect.FieldDescriptor +) + +func init() { + file_tibc_lightclients_tendermint_v1_tendermint_proto_init() + md_Header = File_tibc_lightclients_tendermint_v1_tendermint_proto.Messages().ByName("Header") + fd_Header_signed_header = md_Header.Fields().ByName("signed_header") + fd_Header_validator_set = md_Header.Fields().ByName("validator_set") + fd_Header_trusted_height = md_Header.Fields().ByName("trusted_height") + fd_Header_trusted_validators = md_Header.Fields().ByName("trusted_validators") +} + +var _ protoreflect.Message = (*fastReflection_Header)(nil) + +type fastReflection_Header Header + +func (x *Header) ProtoReflect() protoreflect.Message { + return (*fastReflection_Header)(x) +} + +func (x *Header) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_lightclients_tendermint_v1_tendermint_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_Header_messageType fastReflection_Header_messageType +var _ protoreflect.MessageType = fastReflection_Header_messageType{} + +type fastReflection_Header_messageType struct{} + +func (x fastReflection_Header_messageType) Zero() protoreflect.Message { + return (*fastReflection_Header)(nil) +} +func (x fastReflection_Header_messageType) New() protoreflect.Message { + return new(fastReflection_Header) +} +func (x fastReflection_Header_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Header +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Header) Descriptor() protoreflect.MessageDescriptor { + return md_Header +} + +// 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_Header) Type() protoreflect.MessageType { + return _fastReflection_Header_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Header) New() protoreflect.Message { + return new(fastReflection_Header) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Header) Interface() protoreflect.ProtoMessage { + return (*Header)(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_Header) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.SignedHeader != nil { + value := protoreflect.ValueOfMessage(x.SignedHeader.ProtoReflect()) + if !f(fd_Header_signed_header, value) { + return + } + } + if x.ValidatorSet != nil { + value := protoreflect.ValueOfMessage(x.ValidatorSet.ProtoReflect()) + if !f(fd_Header_validator_set, value) { + return + } + } + if x.TrustedHeight != nil { + value := protoreflect.ValueOfMessage(x.TrustedHeight.ProtoReflect()) + if !f(fd_Header_trusted_height, value) { + return + } + } + if x.TrustedValidators != nil { + value := protoreflect.ValueOfMessage(x.TrustedValidators.ProtoReflect()) + if !f(fd_Header_trusted_validators, 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_Header) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.lightclients.tendermint.v1.Header.signed_header": + return x.SignedHeader != nil + case "tibc.lightclients.tendermint.v1.Header.validator_set": + return x.ValidatorSet != nil + case "tibc.lightclients.tendermint.v1.Header.trusted_height": + return x.TrustedHeight != nil + case "tibc.lightclients.tendermint.v1.Header.trusted_validators": + return x.TrustedValidators != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.Header")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.Header 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_Header) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.lightclients.tendermint.v1.Header.signed_header": + x.SignedHeader = nil + case "tibc.lightclients.tendermint.v1.Header.validator_set": + x.ValidatorSet = nil + case "tibc.lightclients.tendermint.v1.Header.trusted_height": + x.TrustedHeight = nil + case "tibc.lightclients.tendermint.v1.Header.trusted_validators": + x.TrustedValidators = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.Header")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.Header 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_Header) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.lightclients.tendermint.v1.Header.signed_header": + value := x.SignedHeader + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.Header.validator_set": + value := x.ValidatorSet + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.Header.trusted_height": + value := x.TrustedHeight + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.Header.trusted_validators": + value := x.TrustedValidators + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.Header")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.Header 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_Header) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.lightclients.tendermint.v1.Header.signed_header": + x.SignedHeader = value.Message().Interface().(*types.SignedHeader) + case "tibc.lightclients.tendermint.v1.Header.validator_set": + x.ValidatorSet = value.Message().Interface().(*types.ValidatorSet) + case "tibc.lightclients.tendermint.v1.Header.trusted_height": + x.TrustedHeight = value.Message().Interface().(*v1.Height) + case "tibc.lightclients.tendermint.v1.Header.trusted_validators": + x.TrustedValidators = value.Message().Interface().(*types.ValidatorSet) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.Header")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.Header 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_Header) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.tendermint.v1.Header.signed_header": + if x.SignedHeader == nil { + x.SignedHeader = new(types.SignedHeader) + } + return protoreflect.ValueOfMessage(x.SignedHeader.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.Header.validator_set": + if x.ValidatorSet == nil { + x.ValidatorSet = new(types.ValidatorSet) + } + return protoreflect.ValueOfMessage(x.ValidatorSet.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.Header.trusted_height": + if x.TrustedHeight == nil { + x.TrustedHeight = new(v1.Height) + } + return protoreflect.ValueOfMessage(x.TrustedHeight.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.Header.trusted_validators": + if x.TrustedValidators == nil { + x.TrustedValidators = new(types.ValidatorSet) + } + return protoreflect.ValueOfMessage(x.TrustedValidators.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.Header")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.Header 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_Header) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.tendermint.v1.Header.signed_header": + m := new(types.SignedHeader) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.Header.validator_set": + m := new(types.ValidatorSet) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.Header.trusted_height": + m := new(v1.Height) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "tibc.lightclients.tendermint.v1.Header.trusted_validators": + m := new(types.ValidatorSet) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.Header")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.Header 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_Header) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.lightclients.tendermint.v1.Header", 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_Header) 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_Header) 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_Header) 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_Header) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Header) + 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.SignedHeader != nil { + l = options.Size(x.SignedHeader) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ValidatorSet != nil { + l = options.Size(x.ValidatorSet) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.TrustedHeight != nil { + l = options.Size(x.TrustedHeight) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.TrustedValidators != nil { + l = options.Size(x.TrustedValidators) + 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().(*Header) + 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.TrustedValidators != nil { + encoded, err := options.Marshal(x.TrustedValidators) + 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] = 0x22 + } + if x.TrustedHeight != nil { + encoded, err := options.Marshal(x.TrustedHeight) + 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.ValidatorSet != nil { + encoded, err := options.Marshal(x.ValidatorSet) + 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 x.SignedHeader != nil { + encoded, err := options.Marshal(x.SignedHeader) + 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().(*Header) + 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: Header: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Header: 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 SignedHeader", 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.SignedHeader == nil { + x.SignedHeader = &types.SignedHeader{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.SignedHeader); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorSet", 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.ValidatorSet == nil { + x.ValidatorSet = &types.ValidatorSet{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ValidatorSet); 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 TrustedHeight", 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.TrustedHeight == nil { + x.TrustedHeight = &v1.Height{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TrustedHeight); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TrustedValidators", 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.TrustedValidators == nil { + x.TrustedValidators = &types.ValidatorSet{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TrustedValidators); 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_Fraction protoreflect.MessageDescriptor + fd_Fraction_numerator protoreflect.FieldDescriptor + fd_Fraction_denominator protoreflect.FieldDescriptor +) + +func init() { + file_tibc_lightclients_tendermint_v1_tendermint_proto_init() + md_Fraction = File_tibc_lightclients_tendermint_v1_tendermint_proto.Messages().ByName("Fraction") + fd_Fraction_numerator = md_Fraction.Fields().ByName("numerator") + fd_Fraction_denominator = md_Fraction.Fields().ByName("denominator") +} + +var _ protoreflect.Message = (*fastReflection_Fraction)(nil) + +type fastReflection_Fraction Fraction + +func (x *Fraction) ProtoReflect() protoreflect.Message { + return (*fastReflection_Fraction)(x) +} + +func (x *Fraction) slowProtoReflect() protoreflect.Message { + mi := &file_tibc_lightclients_tendermint_v1_tendermint_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_Fraction_messageType fastReflection_Fraction_messageType +var _ protoreflect.MessageType = fastReflection_Fraction_messageType{} + +type fastReflection_Fraction_messageType struct{} + +func (x fastReflection_Fraction_messageType) Zero() protoreflect.Message { + return (*fastReflection_Fraction)(nil) +} +func (x fastReflection_Fraction_messageType) New() protoreflect.Message { + return new(fastReflection_Fraction) +} +func (x fastReflection_Fraction_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Fraction +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Fraction) Descriptor() protoreflect.MessageDescriptor { + return md_Fraction +} + +// 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_Fraction) Type() protoreflect.MessageType { + return _fastReflection_Fraction_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Fraction) New() protoreflect.Message { + return new(fastReflection_Fraction) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Fraction) Interface() protoreflect.ProtoMessage { + return (*Fraction)(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_Fraction) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Numerator != uint64(0) { + value := protoreflect.ValueOfUint64(x.Numerator) + if !f(fd_Fraction_numerator, value) { + return + } + } + if x.Denominator != uint64(0) { + value := protoreflect.ValueOfUint64(x.Denominator) + if !f(fd_Fraction_denominator, 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_Fraction) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "tibc.lightclients.tendermint.v1.Fraction.numerator": + return x.Numerator != uint64(0) + case "tibc.lightclients.tendermint.v1.Fraction.denominator": + return x.Denominator != uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.Fraction")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.Fraction 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_Fraction) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "tibc.lightclients.tendermint.v1.Fraction.numerator": + x.Numerator = uint64(0) + case "tibc.lightclients.tendermint.v1.Fraction.denominator": + x.Denominator = uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.Fraction")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.Fraction 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_Fraction) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "tibc.lightclients.tendermint.v1.Fraction.numerator": + value := x.Numerator + return protoreflect.ValueOfUint64(value) + case "tibc.lightclients.tendermint.v1.Fraction.denominator": + value := x.Denominator + return protoreflect.ValueOfUint64(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.Fraction")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.Fraction 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_Fraction) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "tibc.lightclients.tendermint.v1.Fraction.numerator": + x.Numerator = value.Uint() + case "tibc.lightclients.tendermint.v1.Fraction.denominator": + x.Denominator = value.Uint() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.Fraction")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.Fraction 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_Fraction) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.tendermint.v1.Fraction.numerator": + panic(fmt.Errorf("field numerator of message tibc.lightclients.tendermint.v1.Fraction is not mutable")) + case "tibc.lightclients.tendermint.v1.Fraction.denominator": + panic(fmt.Errorf("field denominator of message tibc.lightclients.tendermint.v1.Fraction is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.Fraction")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.Fraction 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_Fraction) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "tibc.lightclients.tendermint.v1.Fraction.numerator": + return protoreflect.ValueOfUint64(uint64(0)) + case "tibc.lightclients.tendermint.v1.Fraction.denominator": + return protoreflect.ValueOfUint64(uint64(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: tibc.lightclients.tendermint.v1.Fraction")) + } + panic(fmt.Errorf("message tibc.lightclients.tendermint.v1.Fraction 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_Fraction) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in tibc.lightclients.tendermint.v1.Fraction", 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_Fraction) 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_Fraction) 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_Fraction) 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_Fraction) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Fraction) + 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.Numerator != 0 { + n += 1 + runtime.Sov(uint64(x.Numerator)) + } + if x.Denominator != 0 { + n += 1 + runtime.Sov(uint64(x.Denominator)) + } + 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().(*Fraction) + 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.Denominator != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Denominator)) + i-- + dAtA[i] = 0x10 + } + if x.Numerator != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Numerator)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*Fraction) + 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: Fraction: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Fraction: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Numerator", wireType) + } + x.Numerator = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Numerator |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Denominator", wireType) + } + x.Denominator = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Denominator |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: tibc/lightclients/tendermint/v1/tendermint.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) +) + +// ClientState from Tendermint tracks the current validator set, latest height, +// and a possible frozen height. +type ClientState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + TrustLevel *Fraction `protobuf:"bytes,2,opt,name=trust_level,json=trustLevel,proto3" json:"trust_level,omitempty"` + // duration of the period since the LastestTimestamp during which the + // submitted headers are valid for upgrade + TrustingPeriod *durationpb.Duration `protobuf:"bytes,3,opt,name=trusting_period,json=trustingPeriod,proto3" json:"trusting_period,omitempty"` + // duration of the staking unbonding period + UnbondingPeriod *durationpb.Duration `protobuf:"bytes,4,opt,name=unbonding_period,json=unbondingPeriod,proto3" json:"unbonding_period,omitempty"` + // defines how much new (untrusted) header's Time can drift into the future. + MaxClockDrift *durationpb.Duration `protobuf:"bytes,5,opt,name=max_clock_drift,json=maxClockDrift,proto3" json:"max_clock_drift,omitempty"` + // latest height the client was updated to + LatestHeight *v1.Height `protobuf:"bytes,6,opt,name=latest_height,json=latestHeight,proto3" json:"latest_height,omitempty"` + // proof specifications used in verifying counterparty state + ProofSpecs []*_go.ProofSpec `protobuf:"bytes,7,rep,name=proof_specs,json=proofSpecs,proto3" json:"proof_specs,omitempty"` + // merkle_prefix merkle prefix of the counterparty chain. + MerklePrefix *v11.MerklePrefix `protobuf:"bytes,8,opt,name=merkle_prefix,json=merklePrefix,proto3" json:"merkle_prefix,omitempty"` + // period of transaction confirmation delay + TimeDelay uint64 `protobuf:"varint,9,opt,name=time_delay,json=timeDelay,proto3" json:"time_delay,omitempty"` +} + +func (x *ClientState) Reset() { + *x = ClientState{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_lightclients_tendermint_v1_tendermint_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ClientState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ClientState) ProtoMessage() {} + +// Deprecated: Use ClientState.ProtoReflect.Descriptor instead. +func (*ClientState) Descriptor() ([]byte, []int) { + return file_tibc_lightclients_tendermint_v1_tendermint_proto_rawDescGZIP(), []int{0} +} + +func (x *ClientState) GetChainId() string { + if x != nil { + return x.ChainId + } + return "" +} + +func (x *ClientState) GetTrustLevel() *Fraction { + if x != nil { + return x.TrustLevel + } + return nil +} + +func (x *ClientState) GetTrustingPeriod() *durationpb.Duration { + if x != nil { + return x.TrustingPeriod + } + return nil +} + +func (x *ClientState) GetUnbondingPeriod() *durationpb.Duration { + if x != nil { + return x.UnbondingPeriod + } + return nil +} + +func (x *ClientState) GetMaxClockDrift() *durationpb.Duration { + if x != nil { + return x.MaxClockDrift + } + return nil +} + +func (x *ClientState) GetLatestHeight() *v1.Height { + if x != nil { + return x.LatestHeight + } + return nil +} + +func (x *ClientState) GetProofSpecs() []*_go.ProofSpec { + if x != nil { + return x.ProofSpecs + } + return nil +} + +func (x *ClientState) GetMerklePrefix() *v11.MerklePrefix { + if x != nil { + return x.MerklePrefix + } + return nil +} + +func (x *ClientState) GetTimeDelay() uint64 { + if x != nil { + return x.TimeDelay + } + return 0 +} + +// ConsensusState defines the consensus state from Tendermint. +type ConsensusState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // timestamp that corresponds to the block height in which the ConsensusState + // was stored. + Timestamp *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + // commitment root (i.e app hash) + Root *v11.MerkleRoot `protobuf:"bytes,2,opt,name=root,proto3" json:"root,omitempty"` + NextValidatorsHash []byte `protobuf:"bytes,3,opt,name=next_validators_hash,json=nextValidatorsHash,proto3" json:"next_validators_hash,omitempty"` +} + +func (x *ConsensusState) Reset() { + *x = ConsensusState{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_lightclients_tendermint_v1_tendermint_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ConsensusState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ConsensusState) ProtoMessage() {} + +// Deprecated: Use ConsensusState.ProtoReflect.Descriptor instead. +func (*ConsensusState) Descriptor() ([]byte, []int) { + return file_tibc_lightclients_tendermint_v1_tendermint_proto_rawDescGZIP(), []int{1} +} + +func (x *ConsensusState) GetTimestamp() *timestamppb.Timestamp { + if x != nil { + return x.Timestamp + } + return nil +} + +func (x *ConsensusState) GetRoot() *v11.MerkleRoot { + if x != nil { + return x.Root + } + return nil +} + +func (x *ConsensusState) GetNextValidatorsHash() []byte { + if x != nil { + return x.NextValidatorsHash + } + return nil +} + +// Header defines the Tendermint client consensus Header. +// It encapsulates all the information necessary to update from a trusted +// Tendermint ConsensusState. The inclusion of TrustedHeight and +// TrustedValidators allows this update to process correctly, so long as the +// ConsensusState for the TrustedHeight exists, this removes race conditions +// among relayers The SignedHeader and ValidatorSet are the new untrusted update +// fields for the client. The TrustedHeight is the height of a stored +// ConsensusState on the client that will be used to verify the new untrusted +// header. The Trusted ConsensusState must be within the unbonding period of +// current time in order to correctly verify, and the TrustedValidators must +// hash to TrustedConsensusState.NextValidatorsHash since that is the last +// trusted validator set at the TrustedHeight. +type Header struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + SignedHeader *types.SignedHeader `protobuf:"bytes,1,opt,name=signed_header,json=signedHeader,proto3" json:"signed_header,omitempty"` + ValidatorSet *types.ValidatorSet `protobuf:"bytes,2,opt,name=validator_set,json=validatorSet,proto3" json:"validator_set,omitempty"` + TrustedHeight *v1.Height `protobuf:"bytes,3,opt,name=trusted_height,json=trustedHeight,proto3" json:"trusted_height,omitempty"` + TrustedValidators *types.ValidatorSet `protobuf:"bytes,4,opt,name=trusted_validators,json=trustedValidators,proto3" json:"trusted_validators,omitempty"` +} + +func (x *Header) Reset() { + *x = Header{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_lightclients_tendermint_v1_tendermint_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Header) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Header) ProtoMessage() {} + +// Deprecated: Use Header.ProtoReflect.Descriptor instead. +func (*Header) Descriptor() ([]byte, []int) { + return file_tibc_lightclients_tendermint_v1_tendermint_proto_rawDescGZIP(), []int{2} +} + +func (x *Header) GetSignedHeader() *types.SignedHeader { + if x != nil { + return x.SignedHeader + } + return nil +} + +func (x *Header) GetValidatorSet() *types.ValidatorSet { + if x != nil { + return x.ValidatorSet + } + return nil +} + +func (x *Header) GetTrustedHeight() *v1.Height { + if x != nil { + return x.TrustedHeight + } + return nil +} + +func (x *Header) GetTrustedValidators() *types.ValidatorSet { + if x != nil { + return x.TrustedValidators + } + return nil +} + +// Fraction defines the protobuf message type for tmmath.Fraction that only +// supports positive values. +type Fraction struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Numerator uint64 `protobuf:"varint,1,opt,name=numerator,proto3" json:"numerator,omitempty"` + Denominator uint64 `protobuf:"varint,2,opt,name=denominator,proto3" json:"denominator,omitempty"` +} + +func (x *Fraction) Reset() { + *x = Fraction{} + if protoimpl.UnsafeEnabled { + mi := &file_tibc_lightclients_tendermint_v1_tendermint_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Fraction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Fraction) ProtoMessage() {} + +// Deprecated: Use Fraction.ProtoReflect.Descriptor instead. +func (*Fraction) Descriptor() ([]byte, []int) { + return file_tibc_lightclients_tendermint_v1_tendermint_proto_rawDescGZIP(), []int{3} +} + +func (x *Fraction) GetNumerator() uint64 { + if x != nil { + return x.Numerator + } + return 0 +} + +func (x *Fraction) GetDenominator() uint64 { + if x != nil { + return x.Denominator + } + return 0 +} + +var File_tibc_lightclients_tendermint_v1_tendermint_proto protoreflect.FileDescriptor + +var file_tibc_lightclients_tendermint_v1_tendermint_proto_rawDesc = []byte{ + 0x0a, 0x30, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x74, 0x2f, 0x76, + 0x31, 0x2f, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x12, 0x1f, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x74, + 0x2e, 0x76, 0x31, 0x1a, 0x20, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x74, 0x2f, + 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x6d, 0x69, 0x6e, + 0x74, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x69, 0x63, 0x73, 0x32, + 0x33, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 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, 0x1a, 0x20, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x63, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x28, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, + 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, + 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 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, 0x22, 0xe1, 0x04, 0x0a, 0x0b, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, + 0x74, 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x12, + 0x50, 0x0a, 0x0b, 0x74, 0x72, 0x75, 0x73, 0x74, 0x5f, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x6c, 0x69, 0x67, 0x68, + 0x74, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x6d, + 0x69, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x42, + 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0a, 0x74, 0x72, 0x75, 0x73, 0x74, 0x4c, 0x65, 0x76, 0x65, + 0x6c, 0x12, 0x4c, 0x0a, 0x0f, 0x74, 0x72, 0x75, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x65, + 0x72, 0x69, 0x6f, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x08, 0xc8, 0xde, 0x1f, 0x00, 0x98, 0xdf, 0x1f, 0x01, 0x52, + 0x0e, 0x74, 0x72, 0x75, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, + 0x4e, 0x0a, 0x10, 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x65, 0x72, + 0x69, 0x6f, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x08, 0xc8, 0xde, 0x1f, 0x00, 0x98, 0xdf, 0x1f, 0x01, 0x52, 0x0f, + 0x75, 0x6e, 0x62, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, + 0x4b, 0x0a, 0x0f, 0x6d, 0x61, 0x78, 0x5f, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x64, 0x72, 0x69, + 0x66, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x42, 0x08, 0xc8, 0xde, 0x1f, 0x00, 0x98, 0xdf, 0x1f, 0x01, 0x52, 0x0d, 0x6d, + 0x61, 0x78, 0x43, 0x6c, 0x6f, 0x63, 0x6b, 0x44, 0x72, 0x69, 0x66, 0x74, 0x12, 0x46, 0x0a, 0x0d, + 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, + 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0c, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x48, 0x65, + 0x69, 0x67, 0x68, 0x74, 0x12, 0x3b, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x73, 0x70, + 0x65, 0x63, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x63, 0x6f, 0x73, 0x6d, + 0x6f, 0x73, 0x2e, 0x69, 0x63, 0x73, 0x32, 0x33, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x72, 0x6f, 0x6f, + 0x66, 0x53, 0x70, 0x65, 0x63, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x53, 0x70, 0x65, 0x63, + 0x73, 0x12, 0x50, 0x0a, 0x0d, 0x6d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x5f, 0x70, 0x72, 0x65, 0x66, + 0x69, 0x78, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x2e, + 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x42, + 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0c, 0x6d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x50, 0x72, 0x65, + 0x66, 0x69, 0x78, 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x64, 0x65, 0x6c, 0x61, + 0x79, 0x18, 0x09, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x44, 0x65, 0x6c, + 0x61, 0x79, 0x3a, 0x04, 0x88, 0xa0, 0x1f, 0x00, 0x22, 0x81, 0x02, 0x0a, 0x0e, 0x43, 0x6f, 0x6e, + 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x42, 0x0a, 0x09, 0x74, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 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, 0x08, 0xc8, 0xde, 0x1f, 0x00, + 0x90, 0xdf, 0x1f, 0x01, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, + 0x3d, 0x0a, 0x04, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, + 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, + 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x52, 0x6f, + 0x6f, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x04, 0x72, 0x6f, 0x6f, 0x74, 0x12, 0x66, + 0x0a, 0x14, 0x6e, 0x65, 0x78, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, + 0x73, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x34, 0xfa, 0xde, + 0x1f, 0x30, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x63, 0x6f, 0x6d, + 0x65, 0x74, 0x62, 0x66, 0x74, 0x2f, 0x63, 0x6f, 0x6d, 0x65, 0x74, 0x62, 0x66, 0x74, 0x2f, 0x6c, + 0x69, 0x62, 0x73, 0x2f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x2e, 0x48, 0x65, 0x78, 0x42, 0x79, 0x74, + 0x65, 0x73, 0x52, 0x12, 0x6e, 0x65, 0x78, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, + 0x72, 0x73, 0x48, 0x61, 0x73, 0x68, 0x3a, 0x04, 0x88, 0xa0, 0x1f, 0x00, 0x22, 0xb1, 0x02, 0x0a, + 0x06, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x49, 0x0a, 0x0d, 0x73, 0x69, 0x67, 0x6e, 0x65, + 0x64, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, + 0x2e, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x79, 0x70, 0x65, + 0x73, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x42, 0x04, + 0xd0, 0xde, 0x1f, 0x01, 0x52, 0x0c, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x48, 0x65, 0x61, 0x64, + 0x65, 0x72, 0x12, 0x43, 0x0a, 0x0d, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, + 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x74, 0x65, 0x6e, 0x64, + 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x56, 0x61, 0x6c, + 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x65, 0x74, 0x52, 0x0c, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x6f, 0x72, 0x53, 0x65, 0x74, 0x12, 0x48, 0x0a, 0x0e, 0x74, 0x72, 0x75, 0x73, 0x74, + 0x65, 0x64, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1b, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, 0x04, 0xc8, 0xde, + 0x1f, 0x00, 0x52, 0x0d, 0x74, 0x72, 0x75, 0x73, 0x74, 0x65, 0x64, 0x48, 0x65, 0x69, 0x67, 0x68, + 0x74, 0x12, 0x4d, 0x0a, 0x12, 0x74, 0x72, 0x75, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x76, 0x61, 0x6c, + 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, + 0x74, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x74, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, + 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x65, 0x74, 0x52, 0x11, 0x74, + 0x72, 0x75, 0x73, 0x74, 0x65, 0x64, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, + 0x22, 0x4a, 0x0a, 0x08, 0x46, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1c, 0x0a, 0x09, + 0x6e, 0x75, 0x6d, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, + 0x09, 0x6e, 0x75, 0x6d, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, + 0x6e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, + 0x0b, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x42, 0xa4, 0x02, 0x0a, + 0x23, 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x69, 0x62, 0x63, 0x2e, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x63, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x6d, 0x69, 0x6e, + 0x74, 0x2e, 0x76, 0x31, 0x42, 0x0f, 0x54, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x74, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x4d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x62, 0x69, 0x61, 0x6e, 0x6a, 0x69, 0x65, 0x61, 0x69, 0x2f, 0x74, 0x69, + 0x62, 0x63, 0x2d, 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x74, 0x69, 0x62, 0x63, 0x2f, 0x6c, + 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x74, 0x65, 0x6e, 0x64, + 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x3b, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x72, + 0x6d, 0x69, 0x6e, 0x74, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x54, 0x4c, 0x54, 0xaa, 0x02, 0x1f, 0x54, + 0x69, 0x62, 0x63, 0x2e, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, + 0x2e, 0x54, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x74, 0x2e, 0x56, 0x31, 0xca, 0x02, + 0x1f, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, 0x6e, + 0x74, 0x73, 0x5c, 0x54, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x74, 0x5c, 0x56, 0x31, + 0xe2, 0x02, 0x2b, 0x54, 0x69, 0x62, 0x63, 0x5c, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x73, 0x5c, 0x54, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x74, 0x5c, + 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, + 0x22, 0x54, 0x69, 0x62, 0x63, 0x3a, 0x3a, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x73, 0x3a, 0x3a, 0x54, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x74, 0x3a, + 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_tibc_lightclients_tendermint_v1_tendermint_proto_rawDescOnce sync.Once + file_tibc_lightclients_tendermint_v1_tendermint_proto_rawDescData = file_tibc_lightclients_tendermint_v1_tendermint_proto_rawDesc +) + +func file_tibc_lightclients_tendermint_v1_tendermint_proto_rawDescGZIP() []byte { + file_tibc_lightclients_tendermint_v1_tendermint_proto_rawDescOnce.Do(func() { + file_tibc_lightclients_tendermint_v1_tendermint_proto_rawDescData = protoimpl.X.CompressGZIP(file_tibc_lightclients_tendermint_v1_tendermint_proto_rawDescData) + }) + return file_tibc_lightclients_tendermint_v1_tendermint_proto_rawDescData +} + +var file_tibc_lightclients_tendermint_v1_tendermint_proto_msgTypes = make([]protoimpl.MessageInfo, 4) +var file_tibc_lightclients_tendermint_v1_tendermint_proto_goTypes = []interface{}{ + (*ClientState)(nil), // 0: tibc.lightclients.tendermint.v1.ClientState + (*ConsensusState)(nil), // 1: tibc.lightclients.tendermint.v1.ConsensusState + (*Header)(nil), // 2: tibc.lightclients.tendermint.v1.Header + (*Fraction)(nil), // 3: tibc.lightclients.tendermint.v1.Fraction + (*durationpb.Duration)(nil), // 4: google.protobuf.Duration + (*v1.Height)(nil), // 5: tibc.core.client.v1.Height + (*_go.ProofSpec)(nil), // 6: cosmos.ics23.v1.ProofSpec + (*v11.MerklePrefix)(nil), // 7: tibc.core.commitment.v1.MerklePrefix + (*timestamppb.Timestamp)(nil), // 8: google.protobuf.Timestamp + (*v11.MerkleRoot)(nil), // 9: tibc.core.commitment.v1.MerkleRoot + (*types.SignedHeader)(nil), // 10: tendermint.types.SignedHeader + (*types.ValidatorSet)(nil), // 11: tendermint.types.ValidatorSet +} +var file_tibc_lightclients_tendermint_v1_tendermint_proto_depIdxs = []int32{ + 3, // 0: tibc.lightclients.tendermint.v1.ClientState.trust_level:type_name -> tibc.lightclients.tendermint.v1.Fraction + 4, // 1: tibc.lightclients.tendermint.v1.ClientState.trusting_period:type_name -> google.protobuf.Duration + 4, // 2: tibc.lightclients.tendermint.v1.ClientState.unbonding_period:type_name -> google.protobuf.Duration + 4, // 3: tibc.lightclients.tendermint.v1.ClientState.max_clock_drift:type_name -> google.protobuf.Duration + 5, // 4: tibc.lightclients.tendermint.v1.ClientState.latest_height:type_name -> tibc.core.client.v1.Height + 6, // 5: tibc.lightclients.tendermint.v1.ClientState.proof_specs:type_name -> cosmos.ics23.v1.ProofSpec + 7, // 6: tibc.lightclients.tendermint.v1.ClientState.merkle_prefix:type_name -> tibc.core.commitment.v1.MerklePrefix + 8, // 7: tibc.lightclients.tendermint.v1.ConsensusState.timestamp:type_name -> google.protobuf.Timestamp + 9, // 8: tibc.lightclients.tendermint.v1.ConsensusState.root:type_name -> tibc.core.commitment.v1.MerkleRoot + 10, // 9: tibc.lightclients.tendermint.v1.Header.signed_header:type_name -> tendermint.types.SignedHeader + 11, // 10: tibc.lightclients.tendermint.v1.Header.validator_set:type_name -> tendermint.types.ValidatorSet + 5, // 11: tibc.lightclients.tendermint.v1.Header.trusted_height:type_name -> tibc.core.client.v1.Height + 11, // 12: tibc.lightclients.tendermint.v1.Header.trusted_validators:type_name -> tendermint.types.ValidatorSet + 13, // [13:13] is the sub-list for method output_type + 13, // [13:13] is the sub-list for method input_type + 13, // [13:13] is the sub-list for extension type_name + 13, // [13:13] is the sub-list for extension extendee + 0, // [0:13] is the sub-list for field type_name +} + +func init() { file_tibc_lightclients_tendermint_v1_tendermint_proto_init() } +func file_tibc_lightclients_tendermint_v1_tendermint_proto_init() { + if File_tibc_lightclients_tendermint_v1_tendermint_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_tibc_lightclients_tendermint_v1_tendermint_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ClientState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_lightclients_tendermint_v1_tendermint_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ConsensusState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_lightclients_tendermint_v1_tendermint_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Header); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_tibc_lightclients_tendermint_v1_tendermint_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Fraction); 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_tibc_lightclients_tendermint_v1_tendermint_proto_rawDesc, + NumEnums: 0, + NumMessages: 4, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_tibc_lightclients_tendermint_v1_tendermint_proto_goTypes, + DependencyIndexes: file_tibc_lightclients_tendermint_v1_tendermint_proto_depIdxs, + MessageInfos: file_tibc_lightclients_tendermint_v1_tendermint_proto_msgTypes, + }.Build() + File_tibc_lightclients_tendermint_v1_tendermint_proto = out.File + file_tibc_lightclients_tendermint_v1_tendermint_proto_rawDesc = nil + file_tibc_lightclients_tendermint_v1_tendermint_proto_goTypes = nil + file_tibc_lightclients_tendermint_v1_tendermint_proto_depIdxs = nil +} diff --git a/modules/tibc/apps/mt_transfer/depinject.go b/modules/tibc/apps/mt_transfer/depinject.go new file mode 100644 index 00000000..411eaabb --- /dev/null +++ b/modules/tibc/apps/mt_transfer/depinject.go @@ -0,0 +1,69 @@ +package mttransfer + +import ( + "cosmossdk.io/core/appmodule" + "cosmossdk.io/depinject" + "github.com/cosmos/cosmos-sdk/codec" + store "github.com/cosmos/cosmos-sdk/store/types" + + modulev1 "github.com/bianjieai/tibc-go/api/tibc/apps/mt_transfer/module/v1" + "github.com/bianjieai/tibc-go/modules/tibc/apps/mt_transfer/keeper" + "github.com/bianjieai/tibc-go/modules/tibc/apps/mt_transfer/types" +) + +// App Wiring Setup + +func init() { + appmodule.Register(&modulev1.Module{}, + appmodule.Provide(ProvideModule), + ) +} + +var _ appmodule.AppModule = AppModule{} + +// IsOnePerModuleType implements the depinject.OnePerModuleType interface. +func (am AppModule) IsOnePerModuleType() {} + +// IsAppModule implements the appmodule.AppModule interface. +func (am AppModule) IsAppModule() {} + +// Inputs define the module inputs for the depinject. +type Inputs struct { + depinject.In + + Config *modulev1.Module + Cdc codec.Codec + Key *store.KVStoreKey + + ak types.AccountKeeper + mk types.MtKeeper + pk types.PacketKeeper + ck types.ClientKeeper +} + +// Outputs define the module outputs for the depinject. +type Outputs struct { + depinject.Out + + MtTransferKeeper keeper.Keeper + Module appmodule.AppModule +} + +// ProvideModule creates and returns the farm module with the specified inputs. +// +// It takes Inputs as the parameter, which includes the configuration, codec, key, account keeper, bank keeper, governance keeper, coinswap keeper, and legacy subspace. +// It returns Outputs containing the farm keeper and the app module. +func ProvideModule(in Inputs) Outputs { + keeper := keeper.NewKeeper( + in.Cdc, + in.Key, + in.ak, + in.mk, + in.pk, + in.ck, + ) + return Outputs{ + MtTransferKeeper: keeper, + Module: NewAppModule(keeper), + } +} diff --git a/modules/tibc/apps/mt_transfer/handler.go b/modules/tibc/apps/mt_transfer/handler.go index cc25046b..84c16556 100644 --- a/modules/tibc/apps/mt_transfer/handler.go +++ b/modules/tibc/apps/mt_transfer/handler.go @@ -1,4 +1,4 @@ -package mt_transfer +package mttransfer import ( sdk "github.com/cosmos/cosmos-sdk/types" diff --git a/modules/tibc/apps/mt_transfer/keeper/keeper.go b/modules/tibc/apps/mt_transfer/keeper/keeper.go index 28a29f96..ff3df944 100644 --- a/modules/tibc/apps/mt_transfer/keeper/keeper.go +++ b/modules/tibc/apps/mt_transfer/keeper/keeper.go @@ -8,7 +8,6 @@ import ( "github.com/cosmos/cosmos-sdk/store/prefix" storetypes "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" - paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" "github.com/bianjieai/tibc-go/modules/tibc/apps/mt_transfer/types" host "github.com/bianjieai/tibc-go/modules/tibc/core/24-host" @@ -17,7 +16,6 @@ import ( type Keeper struct { storeKey storetypes.StoreKey cdc codec.BinaryCodec - paramSpace paramtypes.Subspace ak types.AccountKeeper mk types.MtKeeper @@ -29,7 +27,6 @@ type Keeper struct { func NewKeeper( cdc codec.BinaryCodec, key storetypes.StoreKey, - paramSpace paramtypes.Subspace, ak types.AccountKeeper, mk types.MtKeeper, pk types.PacketKeeper, @@ -42,7 +39,6 @@ func NewKeeper( return Keeper{ cdc: cdc, storeKey: key, - paramSpace: paramSpace, ak: ak, mk: mk, pk: pk, diff --git a/modules/tibc/apps/mt_transfer/moudle.go b/modules/tibc/apps/mt_transfer/moudle.go index 40286c78..aa663630 100644 --- a/modules/tibc/apps/mt_transfer/moudle.go +++ b/modules/tibc/apps/mt_transfer/moudle.go @@ -1,4 +1,4 @@ -package mt_transfer +package mttransfer import ( "context" diff --git a/modules/tibc/apps/mt_transfer/transfer_test.go b/modules/tibc/apps/mt_transfer/transfer_test.go index 5d76ec65..9bdef728 100644 --- a/modules/tibc/apps/mt_transfer/transfer_test.go +++ b/modules/tibc/apps/mt_transfer/transfer_test.go @@ -1,4 +1,4 @@ -package mt_transfer_test +package mttransfer_test import ( "fmt" diff --git a/modules/tibc/apps/nft_transfer/depinject.go b/modules/tibc/apps/nft_transfer/depinject.go new file mode 100644 index 00000000..c2305e95 --- /dev/null +++ b/modules/tibc/apps/nft_transfer/depinject.go @@ -0,0 +1,70 @@ +package nfttransfer + +import ( + "cosmossdk.io/core/appmodule" + "cosmossdk.io/depinject" + "github.com/cosmos/cosmos-sdk/codec" + store "github.com/cosmos/cosmos-sdk/store/types" + + modulev1 "github.com/bianjieai/tibc-go/api/tibc/apps/nft_transfer/module/v1" + "github.com/bianjieai/tibc-go/modules/tibc/apps/nft_transfer/keeper" + "github.com/bianjieai/tibc-go/modules/tibc/apps/nft_transfer/types" +) + +// App Wiring Setup + +func init() { + appmodule.Register(&modulev1.Module{}, + appmodule.Provide(ProvideModule), + ) +} + +var _ appmodule.AppModule = AppModule{} + +// IsOnePerModuleType implements the depinject.OnePerModuleType interface. +func (am AppModule) IsOnePerModuleType() {} + +// IsAppModule implements the appmodule.AppModule interface. +func (am AppModule) IsAppModule() {} + +// Inputs define the module inputs for the depinject. +type Inputs struct { + depinject.In + + Config *modulev1.Module + Cdc codec.Codec + Key *store.KVStoreKey + + ak types.AccountKeeper + mk types.NftKeeper + pk types.PacketKeeper + ck types.ClientKeeper +} + +// Outputs define the module outputs for the depinject. +type Outputs struct { + depinject.Out + + NftTransferKeeper keeper.Keeper + Module appmodule.AppModule +} + + +// ProvideModule creates and returns the module outputs for the depinject. +// +// It takes Inputs as the parameter, which includes the configuration, codec, key, account keeper, NFT keeper, packet keeper, and client keeper. +// It returns Outputs containing the NFT transfer keeper and the app module. +func ProvideModule(in Inputs) Outputs { + keeper := keeper.NewKeeper( + in.Cdc, + in.Key, + in.ak, + in.mk, + in.pk, + in.ck, + ) + return Outputs{ + NftTransferKeeper: keeper, + Module: NewAppModule(keeper), + } +} diff --git a/modules/tibc/apps/nft_transfer/handler.go b/modules/tibc/apps/nft_transfer/handler.go index 2dc34150..7b263ccc 100644 --- a/modules/tibc/apps/nft_transfer/handler.go +++ b/modules/tibc/apps/nft_transfer/handler.go @@ -1,4 +1,4 @@ -package nft_transfer +package nfttransfer import ( sdk "github.com/cosmos/cosmos-sdk/types" diff --git a/modules/tibc/apps/nft_transfer/keeper/keeper.go b/modules/tibc/apps/nft_transfer/keeper/keeper.go index e7f478df..852948ea 100644 --- a/modules/tibc/apps/nft_transfer/keeper/keeper.go +++ b/modules/tibc/apps/nft_transfer/keeper/keeper.go @@ -8,7 +8,6 @@ import ( "github.com/cosmos/cosmos-sdk/store/prefix" storetypes "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" - paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" "github.com/bianjieai/tibc-go/modules/tibc/apps/nft_transfer/types" host "github.com/bianjieai/tibc-go/modules/tibc/core/24-host" @@ -17,7 +16,6 @@ import ( type Keeper struct { storeKey storetypes.StoreKey cdc codec.BinaryCodec - paramSpace paramtypes.Subspace ak types.AccountKeeper nk types.NftKeeper @@ -29,7 +27,6 @@ type Keeper struct { func NewKeeper( cdc codec.BinaryCodec, key storetypes.StoreKey, - paramSpace paramtypes.Subspace, ak types.AccountKeeper, nk types.NftKeeper, pk types.PacketKeeper, @@ -42,7 +39,6 @@ func NewKeeper( return Keeper{ cdc: cdc, storeKey: key, - paramSpace: paramSpace, ak: ak, nk: nk, pk: pk, diff --git a/modules/tibc/apps/nft_transfer/moudle.go b/modules/tibc/apps/nft_transfer/moudle.go index 1a2f7396..3ad76589 100644 --- a/modules/tibc/apps/nft_transfer/moudle.go +++ b/modules/tibc/apps/nft_transfer/moudle.go @@ -1,4 +1,4 @@ -package nft_transfer +package nfttransfer import ( "context" diff --git a/modules/tibc/apps/nft_transfer/transfer_test.go b/modules/tibc/apps/nft_transfer/transfer_test.go index 08308e3f..34c4feb7 100644 --- a/modules/tibc/apps/nft_transfer/transfer_test.go +++ b/modules/tibc/apps/nft_transfer/transfer_test.go @@ -1,4 +1,4 @@ -package nft_transfer_test +package nfttransfer_test import ( "fmt" diff --git a/modules/tibc/core/depinject.go b/modules/tibc/core/depinject.go index ff5ddd10..c0f0fce8 100644 --- a/modules/tibc/core/depinject.go +++ b/modules/tibc/core/depinject.go @@ -10,7 +10,10 @@ import ( govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" modulev1 "github.com/bianjieai/tibc-go/api/tibc/core/module/v1" + clientkeeper "github.com/bianjieai/tibc-go/modules/tibc/core/02-client/keeper" clienttypes "github.com/bianjieai/tibc-go/modules/tibc/core/02-client/types" + packetkeeper "github.com/bianjieai/tibc-go/modules/tibc/core/04-packet/keeper" + routingkeeper "github.com/bianjieai/tibc-go/modules/tibc/core/26-routing/keeper" "github.com/bianjieai/tibc-go/modules/tibc/core/keeper" ) @@ -29,7 +32,8 @@ func (am AppModule) IsOnePerModuleType() {} // IsAppModule implements the appmodule.AppModule interface. func (am AppModule) IsAppModule() {} -type TibcInputs struct { +// Inputs define the module inputs for the depinject. +type Inputs struct { depinject.In Config *modulev1.Module @@ -39,14 +43,22 @@ type TibcInputs struct { StakingKeeper clienttypes.StakingKeeper } -type TibcOutputs struct { +// Outputs define the module outputs for the depinject. +type Outputs struct { depinject.Out - TibcKeeper *keeper.Keeper - Module appmodule.AppModule + TibcKeeper *keeper.Keeper + Module appmodule.AppModule + ClientKeeper clientkeeper.Keeper + PacketKeeper packetkeeper.Keeper + RoutingKeeper routingkeeper.Keeper } -func ProvideModule(in TibcInputs) TibcOutputs { +// ProvideModule defines a function that provides the TIBC module with necessary inputs and returns the outputs. +// +// Inputs: Inputs struct containing configuration, codec, store key, and staking keeper. +// Outputs: Outputs struct with TIBC keeper, module, client keeper, packet keeper, and routing keeper. +func ProvideModule(in Inputs) Outputs { // default to governance authority if not provided authority := authtypes.NewModuleAddress(govtypes.ModuleName) if in.Config.Authority != "" { @@ -61,5 +73,11 @@ func ProvideModule(in TibcInputs) TibcOutputs { ) m := NewAppModule(keeper) - return TibcOutputs{TibcKeeper: keeper, Module: m} + return Outputs{ + TibcKeeper: keeper, + Module: m, + ClientKeeper: keeper.ClientKeeper, + PacketKeeper: keeper.PacketKeeper, + RoutingKeeper: keeper.RoutingKeeper, + } } diff --git a/proto/tibc/apps/mt_transfer/module/v1/module.proto b/proto/tibc/apps/mt_transfer/module/v1/module.proto new file mode 100644 index 00000000..8f153bc6 --- /dev/null +++ b/proto/tibc/apps/mt_transfer/module/v1/module.proto @@ -0,0 +1,12 @@ +syntax = "proto3"; + +package tibc.apps.mt_transfer.module.v1; + +import "cosmos/app/v1alpha1/module.proto"; + +// Module is the config object of the tibc module. +message Module { + option (cosmos.app.v1alpha1.module) = { + go_import : "github.com/bianjieai/tibc-go/modules/tibc/apps/mt_transfer" + }; +} \ No newline at end of file diff --git a/proto/tibc/apps/nft_transfer/module/v1/module.proto b/proto/tibc/apps/nft_transfer/module/v1/module.proto new file mode 100644 index 00000000..8968085d --- /dev/null +++ b/proto/tibc/apps/nft_transfer/module/v1/module.proto @@ -0,0 +1,12 @@ +syntax = "proto3"; + +package tibc.apps.nft_transfer.module.v1; + +import "cosmos/app/v1alpha1/module.proto"; + +// Module is the config object of the tibc module. +message Module { + option (cosmos.app.v1alpha1.module) = { + go_import : "github.com/bianjieai/tibc-go/modules/tibc/apps/nft_transfer" + }; +} \ No newline at end of file diff --git a/simapp/app.go b/simapp/app.go index 7fcda8da..b8721be9 100644 --- a/simapp/app.go +++ b/simapp/app.go @@ -440,14 +440,14 @@ func NewSimApp( ) // Create Transfer Keepers app.NftTransferKeeper = tibcnfttransferkeeper.NewKeeper( - appCodec, keys[tibcnfttypes.StoreKey], app.GetSubspace(tibcnfttypes.ModuleName), + appCodec, keys[tibcnfttypes.StoreKey], app.AccountKeeper, nftkeeper.NewLegacyKeeper(app.NftKeeper), app.TIBCKeeper.PacketKeeper, app.TIBCKeeper.ClientKeeper, ) // Create Transfer Keepers app.MtTransferKeeper = tibcmttransferkeeper.NewKeeper( - appCodec, keys[tibcnfttypes.StoreKey], app.GetSubspace(tibcnfttypes.ModuleName), + appCodec, keys[tibcnfttypes.StoreKey], app.AccountKeeper, app.MtKeeper, app.TIBCKeeper.PacketKeeper, app.TIBCKeeper.ClientKeeper, )