packet.pulsar.go

// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
package keyshare

import (
	common "github.com/Fairblock/fairyring/api/fairyring/common"
	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_KeysharePacketData                           protoreflect.MessageDescriptor
	fd_KeysharePacketData_noData                    protoreflect.FieldDescriptor
	fd_KeysharePacketData_requestAggrKeysharePacket protoreflect.FieldDescriptor
	fd_KeysharePacketData_getAggrKeysharePacket     protoreflect.FieldDescriptor
	fd_KeysharePacketData_aggrKeyshareDataPacket    protoreflect.FieldDescriptor
	fd_KeysharePacketData_currentKeysPacket         protoreflect.FieldDescriptor
)

func init() {
	file_fairyring_keyshare_packet_proto_init()
	md_KeysharePacketData = File_fairyring_keyshare_packet_proto.Messages().ByName("KeysharePacketData")
	fd_KeysharePacketData_noData = md_KeysharePacketData.Fields().ByName("noData")
	fd_KeysharePacketData_requestAggrKeysharePacket = md_KeysharePacketData.Fields().ByName("requestAggrKeysharePacket")
	fd_KeysharePacketData_getAggrKeysharePacket = md_KeysharePacketData.Fields().ByName("getAggrKeysharePacket")
	fd_KeysharePacketData_aggrKeyshareDataPacket = md_KeysharePacketData.Fields().ByName("aggrKeyshareDataPacket")
	fd_KeysharePacketData_currentKeysPacket = md_KeysharePacketData.Fields().ByName("currentKeysPacket")
}

var _ protoreflect.Message = (*fastReflection_KeysharePacketData)(nil)

type fastReflection_KeysharePacketData KeysharePacketData

func (x *KeysharePacketData) ProtoReflect() protoreflect.Message {
	return (*fastReflection_KeysharePacketData)(x)
}

func (x *KeysharePacketData) slowProtoReflect() protoreflect.Message {
	mi := &file_fairyring_keyshare_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_KeysharePacketData_messageType fastReflection_KeysharePacketData_messageType
var _ protoreflect.MessageType = fastReflection_KeysharePacketData_messageType{}

type fastReflection_KeysharePacketData_messageType struct{}

func (x fastReflection_KeysharePacketData_messageType) Zero() protoreflect.Message {
	return (*fastReflection_KeysharePacketData)(nil)
}
func (x fastReflection_KeysharePacketData_messageType) New() protoreflect.Message {
	return new(fastReflection_KeysharePacketData)
}
func (x fastReflection_KeysharePacketData_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_KeysharePacketData
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_KeysharePacketData) Descriptor() protoreflect.MessageDescriptor {
	return md_KeysharePacketData
}

// 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_KeysharePacketData) Type() protoreflect.MessageType {
	return _fastReflection_KeysharePacketData_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_KeysharePacketData) New() protoreflect.Message {
	return new(fastReflection_KeysharePacketData)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_KeysharePacketData) Interface() protoreflect.ProtoMessage {
	return (*KeysharePacketData)(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_KeysharePacketData) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Packet != nil {
		switch o := x.Packet.(type) {
		case *KeysharePacketData_NoData:
			v := o.NoData
			value := protoreflect.ValueOfMessage(v.ProtoReflect())
			if !f(fd_KeysharePacketData_noData, value) {
				return
			}
		case *KeysharePacketData_RequestAggrKeysharePacket:
			v := o.RequestAggrKeysharePacket
			value := protoreflect.ValueOfMessage(v.ProtoReflect())
			if !f(fd_KeysharePacketData_requestAggrKeysharePacket, value) {
				return
			}
		case *KeysharePacketData_GetAggrKeysharePacket:
			v := o.GetAggrKeysharePacket
			value := protoreflect.ValueOfMessage(v.ProtoReflect())
			if !f(fd_KeysharePacketData_getAggrKeysharePacket, value) {
				return
			}
		case *KeysharePacketData_AggrKeyshareDataPacket:
			v := o.AggrKeyshareDataPacket
			value := protoreflect.ValueOfMessage(v.ProtoReflect())
			if !f(fd_KeysharePacketData_aggrKeyshareDataPacket, value) {
				return
			}
		case *KeysharePacketData_CurrentKeysPacket:
			v := o.CurrentKeysPacket
			value := protoreflect.ValueOfMessage(v.ProtoReflect())
			if !f(fd_KeysharePacketData_currentKeysPacket, 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_KeysharePacketData) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "fairyring.keyshare.KeysharePacketData.noData":
		if x.Packet == nil {
			return false
		} else if _, ok := x.Packet.(*KeysharePacketData_NoData); ok {
			return true
		} else {
			return false
		}
	case "fairyring.keyshare.KeysharePacketData.requestAggrKeysharePacket":
		if x.Packet == nil {
			return false
		} else if _, ok := x.Packet.(*KeysharePacketData_RequestAggrKeysharePacket); ok {
			return true
		} else {
			return false
		}
	case "fairyring.keyshare.KeysharePacketData.getAggrKeysharePacket":
		if x.Packet == nil {
			return false
		} else if _, ok := x.Packet.(*KeysharePacketData_GetAggrKeysharePacket); ok {
			return true
		} else {
			return false
		}
	case "fairyring.keyshare.KeysharePacketData.aggrKeyshareDataPacket":
		if x.Packet == nil {
			return false
		} else if _, ok := x.Packet.(*KeysharePacketData_AggrKeyshareDataPacket); ok {
			return true
		} else {
			return false
		}
	case "fairyring.keyshare.KeysharePacketData.currentKeysPacket":
		if x.Packet == nil {
			return false
		} else if _, ok := x.Packet.(*KeysharePacketData_CurrentKeysPacket); ok {
			return true
		} else {
			return false
		}
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.KeysharePacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.KeysharePacketData 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_KeysharePacketData) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "fairyring.keyshare.KeysharePacketData.noData":
		x.Packet = nil
	case "fairyring.keyshare.KeysharePacketData.requestAggrKeysharePacket":
		x.Packet = nil
	case "fairyring.keyshare.KeysharePacketData.getAggrKeysharePacket":
		x.Packet = nil
	case "fairyring.keyshare.KeysharePacketData.aggrKeyshareDataPacket":
		x.Packet = nil
	case "fairyring.keyshare.KeysharePacketData.currentKeysPacket":
		x.Packet = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.KeysharePacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.KeysharePacketData 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_KeysharePacketData) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "fairyring.keyshare.KeysharePacketData.noData":
		if x.Packet == nil {
			return protoreflect.ValueOfMessage((*NoData)(nil).ProtoReflect())
		} else if v, ok := x.Packet.(*KeysharePacketData_NoData); ok {
			return protoreflect.ValueOfMessage(v.NoData.ProtoReflect())
		} else {
			return protoreflect.ValueOfMessage((*NoData)(nil).ProtoReflect())
		}
	case "fairyring.keyshare.KeysharePacketData.requestAggrKeysharePacket":
		if x.Packet == nil {
			return protoreflect.ValueOfMessage((*RequestAggrKeysharePacketData)(nil).ProtoReflect())
		} else if v, ok := x.Packet.(*KeysharePacketData_RequestAggrKeysharePacket); ok {
			return protoreflect.ValueOfMessage(v.RequestAggrKeysharePacket.ProtoReflect())
		} else {
			return protoreflect.ValueOfMessage((*RequestAggrKeysharePacketData)(nil).ProtoReflect())
		}
	case "fairyring.keyshare.KeysharePacketData.getAggrKeysharePacket":
		if x.Packet == nil {
			return protoreflect.ValueOfMessage((*GetAggrKeysharePacketData)(nil).ProtoReflect())
		} else if v, ok := x.Packet.(*KeysharePacketData_GetAggrKeysharePacket); ok {
			return protoreflect.ValueOfMessage(v.GetAggrKeysharePacket.ProtoReflect())
		} else {
			return protoreflect.ValueOfMessage((*GetAggrKeysharePacketData)(nil).ProtoReflect())
		}
	case "fairyring.keyshare.KeysharePacketData.aggrKeyshareDataPacket":
		if x.Packet == nil {
			return protoreflect.ValueOfMessage((*AggrKeyshareDataPacketData)(nil).ProtoReflect())
		} else if v, ok := x.Packet.(*KeysharePacketData_AggrKeyshareDataPacket); ok {
			return protoreflect.ValueOfMessage(v.AggrKeyshareDataPacket.ProtoReflect())
		} else {
			return protoreflect.ValueOfMessage((*AggrKeyshareDataPacketData)(nil).ProtoReflect())
		}
	case "fairyring.keyshare.KeysharePacketData.currentKeysPacket":
		if x.Packet == nil {
			return protoreflect.ValueOfMessage((*CurrentKeysPacketData)(nil).ProtoReflect())
		} else if v, ok := x.Packet.(*KeysharePacketData_CurrentKeysPacket); ok {
			return protoreflect.ValueOfMessage(v.CurrentKeysPacket.ProtoReflect())
		} else {
			return protoreflect.ValueOfMessage((*CurrentKeysPacketData)(nil).ProtoReflect())
		}
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.KeysharePacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.KeysharePacketData 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_KeysharePacketData) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "fairyring.keyshare.KeysharePacketData.noData":
		cv := value.Message().Interface().(*NoData)
		x.Packet = &KeysharePacketData_NoData{NoData: cv}
	case "fairyring.keyshare.KeysharePacketData.requestAggrKeysharePacket":
		cv := value.Message().Interface().(*RequestAggrKeysharePacketData)
		x.Packet = &KeysharePacketData_RequestAggrKeysharePacket{RequestAggrKeysharePacket: cv}
	case "fairyring.keyshare.KeysharePacketData.getAggrKeysharePacket":
		cv := value.Message().Interface().(*GetAggrKeysharePacketData)
		x.Packet = &KeysharePacketData_GetAggrKeysharePacket{GetAggrKeysharePacket: cv}
	case "fairyring.keyshare.KeysharePacketData.aggrKeyshareDataPacket":
		cv := value.Message().Interface().(*AggrKeyshareDataPacketData)
		x.Packet = &KeysharePacketData_AggrKeyshareDataPacket{AggrKeyshareDataPacket: cv}
	case "fairyring.keyshare.KeysharePacketData.currentKeysPacket":
		cv := value.Message().Interface().(*CurrentKeysPacketData)
		x.Packet = &KeysharePacketData_CurrentKeysPacket{CurrentKeysPacket: cv}
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.KeysharePacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.KeysharePacketData 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_KeysharePacketData) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "fairyring.keyshare.KeysharePacketData.noData":
		if x.Packet == nil {
			value := &NoData{}
			oneofValue := &KeysharePacketData_NoData{NoData: value}
			x.Packet = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
		switch m := x.Packet.(type) {
		case *KeysharePacketData_NoData:
			return protoreflect.ValueOfMessage(m.NoData.ProtoReflect())
		default:
			value := &NoData{}
			oneofValue := &KeysharePacketData_NoData{NoData: value}
			x.Packet = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
	case "fairyring.keyshare.KeysharePacketData.requestAggrKeysharePacket":
		if x.Packet == nil {
			value := &RequestAggrKeysharePacketData{}
			oneofValue := &KeysharePacketData_RequestAggrKeysharePacket{RequestAggrKeysharePacket: value}
			x.Packet = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
		switch m := x.Packet.(type) {
		case *KeysharePacketData_RequestAggrKeysharePacket:
			return protoreflect.ValueOfMessage(m.RequestAggrKeysharePacket.ProtoReflect())
		default:
			value := &RequestAggrKeysharePacketData{}
			oneofValue := &KeysharePacketData_RequestAggrKeysharePacket{RequestAggrKeysharePacket: value}
			x.Packet = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
	case "fairyring.keyshare.KeysharePacketData.getAggrKeysharePacket":
		if x.Packet == nil {
			value := &GetAggrKeysharePacketData{}
			oneofValue := &KeysharePacketData_GetAggrKeysharePacket{GetAggrKeysharePacket: value}
			x.Packet = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
		switch m := x.Packet.(type) {
		case *KeysharePacketData_GetAggrKeysharePacket:
			return protoreflect.ValueOfMessage(m.GetAggrKeysharePacket.ProtoReflect())
		default:
			value := &GetAggrKeysharePacketData{}
			oneofValue := &KeysharePacketData_GetAggrKeysharePacket{GetAggrKeysharePacket: value}
			x.Packet = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
	case "fairyring.keyshare.KeysharePacketData.aggrKeyshareDataPacket":
		if x.Packet == nil {
			value := &AggrKeyshareDataPacketData{}
			oneofValue := &KeysharePacketData_AggrKeyshareDataPacket{AggrKeyshareDataPacket: value}
			x.Packet = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
		switch m := x.Packet.(type) {
		case *KeysharePacketData_AggrKeyshareDataPacket:
			return protoreflect.ValueOfMessage(m.AggrKeyshareDataPacket.ProtoReflect())
		default:
			value := &AggrKeyshareDataPacketData{}
			oneofValue := &KeysharePacketData_AggrKeyshareDataPacket{AggrKeyshareDataPacket: value}
			x.Packet = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
	case "fairyring.keyshare.KeysharePacketData.currentKeysPacket":
		if x.Packet == nil {
			value := &CurrentKeysPacketData{}
			oneofValue := &KeysharePacketData_CurrentKeysPacket{CurrentKeysPacket: value}
			x.Packet = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
		switch m := x.Packet.(type) {
		case *KeysharePacketData_CurrentKeysPacket:
			return protoreflect.ValueOfMessage(m.CurrentKeysPacket.ProtoReflect())
		default:
			value := &CurrentKeysPacketData{}
			oneofValue := &KeysharePacketData_CurrentKeysPacket{CurrentKeysPacket: value}
			x.Packet = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.KeysharePacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.KeysharePacketData 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_KeysharePacketData) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "fairyring.keyshare.KeysharePacketData.noData":
		value := &NoData{}
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "fairyring.keyshare.KeysharePacketData.requestAggrKeysharePacket":
		value := &RequestAggrKeysharePacketData{}
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "fairyring.keyshare.KeysharePacketData.getAggrKeysharePacket":
		value := &GetAggrKeysharePacketData{}
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "fairyring.keyshare.KeysharePacketData.aggrKeyshareDataPacket":
		value := &AggrKeyshareDataPacketData{}
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "fairyring.keyshare.KeysharePacketData.currentKeysPacket":
		value := &CurrentKeysPacketData{}
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.KeysharePacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.KeysharePacketData 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_KeysharePacketData) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	case "fairyring.keyshare.KeysharePacketData.packet":
		if x.Packet == nil {
			return nil
		}
		switch x.Packet.(type) {
		case *KeysharePacketData_NoData:
			return x.Descriptor().Fields().ByName("noData")
		case *KeysharePacketData_RequestAggrKeysharePacket:
			return x.Descriptor().Fields().ByName("requestAggrKeysharePacket")
		case *KeysharePacketData_GetAggrKeysharePacket:
			return x.Descriptor().Fields().ByName("getAggrKeysharePacket")
		case *KeysharePacketData_AggrKeyshareDataPacket:
			return x.Descriptor().Fields().ByName("aggrKeyshareDataPacket")
		case *KeysharePacketData_CurrentKeysPacket:
			return x.Descriptor().Fields().ByName("currentKeysPacket")
		}
	default:
		panic(fmt.Errorf("%s is not a oneof field in fairyring.keyshare.KeysharePacketData", 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_KeysharePacketData) 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_KeysharePacketData) 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_KeysharePacketData) 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_KeysharePacketData) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*KeysharePacketData)
		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.Packet.(type) {
		case *KeysharePacketData_NoData:
			if x == nil {
				break
			}
			l = options.Size(x.NoData)
			n += 1 + l + runtime.Sov(uint64(l))
		case *KeysharePacketData_RequestAggrKeysharePacket:
			if x == nil {
				break
			}
			l = options.Size(x.RequestAggrKeysharePacket)
			n += 1 + l + runtime.Sov(uint64(l))
		case *KeysharePacketData_GetAggrKeysharePacket:
			if x == nil {
				break
			}
			l = options.Size(x.GetAggrKeysharePacket)
			n += 1 + l + runtime.Sov(uint64(l))
		case *KeysharePacketData_AggrKeyshareDataPacket:
			if x == nil {
				break
			}
			l = options.Size(x.AggrKeyshareDataPacket)
			n += 1 + l + runtime.Sov(uint64(l))
		case *KeysharePacketData_CurrentKeysPacket:
			if x == nil {
				break
			}
			l = options.Size(x.CurrentKeysPacket)
			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().(*KeysharePacketData)
		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.Packet.(type) {
		case *KeysharePacketData_NoData:
			encoded, err := options.Marshal(x.NoData)
			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
		case *KeysharePacketData_RequestAggrKeysharePacket:
			encoded, err := options.Marshal(x.RequestAggrKeysharePacket)
			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
		case *KeysharePacketData_GetAggrKeysharePacket:
			encoded, err := options.Marshal(x.GetAggrKeysharePacket)
			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
		case *KeysharePacketData_AggrKeyshareDataPacket:
			encoded, err := options.Marshal(x.AggrKeyshareDataPacket)
			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
		case *KeysharePacketData_CurrentKeysPacket:
			encoded, err := options.Marshal(x.CurrentKeysPacket)
			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 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().(*KeysharePacketData)
		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: KeysharePacketData: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: KeysharePacketData: 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 NoData", 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
				}
				v := &NoData{}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				x.Packet = &KeysharePacketData_NoData{v}
				iNdEx = postIndex
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RequestAggrKeysharePacket", 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
				}
				v := &RequestAggrKeysharePacketData{}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				x.Packet = &KeysharePacketData_RequestAggrKeysharePacket{v}
				iNdEx = postIndex
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field GetAggrKeysharePacket", 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
				}
				v := &GetAggrKeysharePacketData{}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				x.Packet = &KeysharePacketData_GetAggrKeysharePacket{v}
				iNdEx = postIndex
			case 4:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field AggrKeyshareDataPacket", 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
				}
				v := &AggrKeyshareDataPacketData{}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				x.Packet = &KeysharePacketData_AggrKeyshareDataPacket{v}
				iNdEx = postIndex
			case 5:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CurrentKeysPacket", 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
				}
				v := &CurrentKeysPacketData{}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				x.Packet = &KeysharePacketData_CurrentKeysPacket{v}
				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_NoData protoreflect.MessageDescriptor
)

func init() {
	file_fairyring_keyshare_packet_proto_init()
	md_NoData = File_fairyring_keyshare_packet_proto.Messages().ByName("NoData")
}

var _ protoreflect.Message = (*fastReflection_NoData)(nil)

type fastReflection_NoData NoData

func (x *NoData) ProtoReflect() protoreflect.Message {
	return (*fastReflection_NoData)(x)
}

func (x *NoData) slowProtoReflect() protoreflect.Message {
	mi := &file_fairyring_keyshare_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_NoData_messageType fastReflection_NoData_messageType
var _ protoreflect.MessageType = fastReflection_NoData_messageType{}

type fastReflection_NoData_messageType struct{}

func (x fastReflection_NoData_messageType) Zero() protoreflect.Message {
	return (*fastReflection_NoData)(nil)
}
func (x fastReflection_NoData_messageType) New() protoreflect.Message {
	return new(fastReflection_NoData)
}
func (x fastReflection_NoData_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_NoData
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_NoData) Descriptor() protoreflect.MessageDescriptor {
	return md_NoData
}

// 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_NoData) Type() protoreflect.MessageType {
	return _fastReflection_NoData_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_NoData) New() protoreflect.Message {
	return new(fastReflection_NoData)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_NoData) Interface() protoreflect.ProtoMessage {
	return (*NoData)(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_NoData) 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_NoData) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.NoData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.NoData 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_NoData) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.NoData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.NoData 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_NoData) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.NoData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.NoData 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_NoData) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.NoData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.NoData 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_NoData) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.NoData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.NoData 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_NoData) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.NoData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.NoData 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_NoData) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in fairyring.keyshare.NoData", 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_NoData) 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_NoData) 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_NoData) 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_NoData) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*NoData)
		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().(*NoData)
		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().(*NoData)
		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: NoData: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: NoData: 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_RequestAggrKeysharePacketData             protoreflect.MessageDescriptor
	fd_RequestAggrKeysharePacketData_requester   protoreflect.FieldDescriptor
	fd_RequestAggrKeysharePacketData_proposal_id protoreflect.FieldDescriptor
	fd_RequestAggrKeysharePacketData_request_id  protoreflect.FieldDescriptor
)

func init() {
	file_fairyring_keyshare_packet_proto_init()
	md_RequestAggrKeysharePacketData = File_fairyring_keyshare_packet_proto.Messages().ByName("RequestAggrKeysharePacketData")
	fd_RequestAggrKeysharePacketData_requester = md_RequestAggrKeysharePacketData.Fields().ByName("requester")
	fd_RequestAggrKeysharePacketData_proposal_id = md_RequestAggrKeysharePacketData.Fields().ByName("proposal_id")
	fd_RequestAggrKeysharePacketData_request_id = md_RequestAggrKeysharePacketData.Fields().ByName("request_id")
}

var _ protoreflect.Message = (*fastReflection_RequestAggrKeysharePacketData)(nil)

type fastReflection_RequestAggrKeysharePacketData RequestAggrKeysharePacketData

func (x *RequestAggrKeysharePacketData) ProtoReflect() protoreflect.Message {
	return (*fastReflection_RequestAggrKeysharePacketData)(x)
}

func (x *RequestAggrKeysharePacketData) slowProtoReflect() protoreflect.Message {
	mi := &file_fairyring_keyshare_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_RequestAggrKeysharePacketData_messageType fastReflection_RequestAggrKeysharePacketData_messageType
var _ protoreflect.MessageType = fastReflection_RequestAggrKeysharePacketData_messageType{}

type fastReflection_RequestAggrKeysharePacketData_messageType struct{}

func (x fastReflection_RequestAggrKeysharePacketData_messageType) Zero() protoreflect.Message {
	return (*fastReflection_RequestAggrKeysharePacketData)(nil)
}
func (x fastReflection_RequestAggrKeysharePacketData_messageType) New() protoreflect.Message {
	return new(fastReflection_RequestAggrKeysharePacketData)
}
func (x fastReflection_RequestAggrKeysharePacketData_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_RequestAggrKeysharePacketData
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_RequestAggrKeysharePacketData) Descriptor() protoreflect.MessageDescriptor {
	return md_RequestAggrKeysharePacketData
}

// 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_RequestAggrKeysharePacketData) Type() protoreflect.MessageType {
	return _fastReflection_RequestAggrKeysharePacketData_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_RequestAggrKeysharePacketData) New() protoreflect.Message {
	return new(fastReflection_RequestAggrKeysharePacketData)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_RequestAggrKeysharePacketData) Interface() protoreflect.ProtoMessage {
	return (*RequestAggrKeysharePacketData)(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_RequestAggrKeysharePacketData) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Requester != "" {
		value := protoreflect.ValueOfString(x.Requester)
		if !f(fd_RequestAggrKeysharePacketData_requester, value) {
			return
		}
	}
	if x.Id != nil {
		switch o := x.Id.(type) {
		case *RequestAggrKeysharePacketData_ProposalId:
			v := o.ProposalId
			value := protoreflect.ValueOfString(v)
			if !f(fd_RequestAggrKeysharePacketData_proposal_id, value) {
				return
			}
		case *RequestAggrKeysharePacketData_RequestId:
			v := o.RequestId
			value := protoreflect.ValueOfString(v)
			if !f(fd_RequestAggrKeysharePacketData_request_id, value) {
				return
			}
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_RequestAggrKeysharePacketData) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "fairyring.keyshare.RequestAggrKeysharePacketData.requester":
		return x.Requester != ""
	case "fairyring.keyshare.RequestAggrKeysharePacketData.proposal_id":
		if x.Id == nil {
			return false
		} else if _, ok := x.Id.(*RequestAggrKeysharePacketData_ProposalId); ok {
			return true
		} else {
			return false
		}
	case "fairyring.keyshare.RequestAggrKeysharePacketData.request_id":
		if x.Id == nil {
			return false
		} else if _, ok := x.Id.(*RequestAggrKeysharePacketData_RequestId); ok {
			return true
		} else {
			return false
		}
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.RequestAggrKeysharePacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.RequestAggrKeysharePacketData 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_RequestAggrKeysharePacketData) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "fairyring.keyshare.RequestAggrKeysharePacketData.requester":
		x.Requester = ""
	case "fairyring.keyshare.RequestAggrKeysharePacketData.proposal_id":
		x.Id = nil
	case "fairyring.keyshare.RequestAggrKeysharePacketData.request_id":
		x.Id = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.RequestAggrKeysharePacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.RequestAggrKeysharePacketData 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_RequestAggrKeysharePacketData) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "fairyring.keyshare.RequestAggrKeysharePacketData.requester":
		value := x.Requester
		return protoreflect.ValueOfString(value)
	case "fairyring.keyshare.RequestAggrKeysharePacketData.proposal_id":
		if x.Id == nil {
			return protoreflect.ValueOfString("")
		} else if v, ok := x.Id.(*RequestAggrKeysharePacketData_ProposalId); ok {
			return protoreflect.ValueOfString(v.ProposalId)
		} else {
			return protoreflect.ValueOfString("")
		}
	case "fairyring.keyshare.RequestAggrKeysharePacketData.request_id":
		if x.Id == nil {
			return protoreflect.ValueOfString("")
		} else if v, ok := x.Id.(*RequestAggrKeysharePacketData_RequestId); ok {
			return protoreflect.ValueOfString(v.RequestId)
		} else {
			return protoreflect.ValueOfString("")
		}
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.RequestAggrKeysharePacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.RequestAggrKeysharePacketData 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_RequestAggrKeysharePacketData) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "fairyring.keyshare.RequestAggrKeysharePacketData.requester":
		x.Requester = value.Interface().(string)
	case "fairyring.keyshare.RequestAggrKeysharePacketData.proposal_id":
		cv := value.Interface().(string)
		x.Id = &RequestAggrKeysharePacketData_ProposalId{ProposalId: cv}
	case "fairyring.keyshare.RequestAggrKeysharePacketData.request_id":
		cv := value.Interface().(string)
		x.Id = &RequestAggrKeysharePacketData_RequestId{RequestId: cv}
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.RequestAggrKeysharePacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.RequestAggrKeysharePacketData 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_RequestAggrKeysharePacketData) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "fairyring.keyshare.RequestAggrKeysharePacketData.requester":
		panic(fmt.Errorf("field requester of message fairyring.keyshare.RequestAggrKeysharePacketData is not mutable"))
	case "fairyring.keyshare.RequestAggrKeysharePacketData.proposal_id":
		panic(fmt.Errorf("field proposal_id of message fairyring.keyshare.RequestAggrKeysharePacketData is not mutable"))
	case "fairyring.keyshare.RequestAggrKeysharePacketData.request_id":
		panic(fmt.Errorf("field request_id of message fairyring.keyshare.RequestAggrKeysharePacketData is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.RequestAggrKeysharePacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.RequestAggrKeysharePacketData 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_RequestAggrKeysharePacketData) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "fairyring.keyshare.RequestAggrKeysharePacketData.requester":
		return protoreflect.ValueOfString("")
	case "fairyring.keyshare.RequestAggrKeysharePacketData.proposal_id":
		return protoreflect.ValueOfString("")
	case "fairyring.keyshare.RequestAggrKeysharePacketData.request_id":
		return protoreflect.ValueOfString("")
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.RequestAggrKeysharePacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.RequestAggrKeysharePacketData 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_RequestAggrKeysharePacketData) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	case "fairyring.keyshare.RequestAggrKeysharePacketData.id":
		if x.Id == nil {
			return nil
		}
		switch x.Id.(type) {
		case *RequestAggrKeysharePacketData_ProposalId:
			return x.Descriptor().Fields().ByName("proposal_id")
		case *RequestAggrKeysharePacketData_RequestId:
			return x.Descriptor().Fields().ByName("request_id")
		}
	default:
		panic(fmt.Errorf("%s is not a oneof field in fairyring.keyshare.RequestAggrKeysharePacketData", 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_RequestAggrKeysharePacketData) 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_RequestAggrKeysharePacketData) 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_RequestAggrKeysharePacketData) 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_RequestAggrKeysharePacketData) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*RequestAggrKeysharePacketData)
		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.Requester)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		switch x := x.Id.(type) {
		case *RequestAggrKeysharePacketData_ProposalId:
			if x == nil {
				break
			}
			l = len(x.ProposalId)
			n += 1 + l + runtime.Sov(uint64(l))
		case *RequestAggrKeysharePacketData_RequestId:
			if x == nil {
				break
			}
			l = len(x.RequestId)
			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().(*RequestAggrKeysharePacketData)
		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.Id.(type) {
		case *RequestAggrKeysharePacketData_ProposalId:
			i -= len(x.ProposalId)
			copy(dAtA[i:], x.ProposalId)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ProposalId)))
			i--
			dAtA[i] = 0x12
		case *RequestAggrKeysharePacketData_RequestId:
			i -= len(x.RequestId)
			copy(dAtA[i:], x.RequestId)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RequestId)))
			i--
			dAtA[i] = 0x1a
		}
		if len(x.Requester) > 0 {
			i -= len(x.Requester)
			copy(dAtA[i:], x.Requester)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Requester)))
			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().(*RequestAggrKeysharePacketData)
		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: RequestAggrKeysharePacketData: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: RequestAggrKeysharePacketData: 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 Requester", 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.Requester = 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 ProposalId", 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 = &RequestAggrKeysharePacketData_ProposalId{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 RequestId", 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 = &RequestAggrKeysharePacketData_RequestId{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_RequestAggrKeysharePacketAck          protoreflect.MessageDescriptor
	fd_RequestAggrKeysharePacketAck_identity protoreflect.FieldDescriptor
	fd_RequestAggrKeysharePacketAck_pubkey   protoreflect.FieldDescriptor
)

func init() {
	file_fairyring_keyshare_packet_proto_init()
	md_RequestAggrKeysharePacketAck = File_fairyring_keyshare_packet_proto.Messages().ByName("RequestAggrKeysharePacketAck")
	fd_RequestAggrKeysharePacketAck_identity = md_RequestAggrKeysharePacketAck.Fields().ByName("identity")
	fd_RequestAggrKeysharePacketAck_pubkey = md_RequestAggrKeysharePacketAck.Fields().ByName("pubkey")
}

var _ protoreflect.Message = (*fastReflection_RequestAggrKeysharePacketAck)(nil)

type fastReflection_RequestAggrKeysharePacketAck RequestAggrKeysharePacketAck

func (x *RequestAggrKeysharePacketAck) ProtoReflect() protoreflect.Message {
	return (*fastReflection_RequestAggrKeysharePacketAck)(x)
}

func (x *RequestAggrKeysharePacketAck) slowProtoReflect() protoreflect.Message {
	mi := &file_fairyring_keyshare_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_RequestAggrKeysharePacketAck_messageType fastReflection_RequestAggrKeysharePacketAck_messageType
var _ protoreflect.MessageType = fastReflection_RequestAggrKeysharePacketAck_messageType{}

type fastReflection_RequestAggrKeysharePacketAck_messageType struct{}

func (x fastReflection_RequestAggrKeysharePacketAck_messageType) Zero() protoreflect.Message {
	return (*fastReflection_RequestAggrKeysharePacketAck)(nil)
}
func (x fastReflection_RequestAggrKeysharePacketAck_messageType) New() protoreflect.Message {
	return new(fastReflection_RequestAggrKeysharePacketAck)
}
func (x fastReflection_RequestAggrKeysharePacketAck_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_RequestAggrKeysharePacketAck
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_RequestAggrKeysharePacketAck) Descriptor() protoreflect.MessageDescriptor {
	return md_RequestAggrKeysharePacketAck
}

// 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_RequestAggrKeysharePacketAck) Type() protoreflect.MessageType {
	return _fastReflection_RequestAggrKeysharePacketAck_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_RequestAggrKeysharePacketAck) New() protoreflect.Message {
	return new(fastReflection_RequestAggrKeysharePacketAck)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_RequestAggrKeysharePacketAck) Interface() protoreflect.ProtoMessage {
	return (*RequestAggrKeysharePacketAck)(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_RequestAggrKeysharePacketAck) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Identity != "" {
		value := protoreflect.ValueOfString(x.Identity)
		if !f(fd_RequestAggrKeysharePacketAck_identity, value) {
			return
		}
	}
	if x.Pubkey != "" {
		value := protoreflect.ValueOfString(x.Pubkey)
		if !f(fd_RequestAggrKeysharePacketAck_pubkey, 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_RequestAggrKeysharePacketAck) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "fairyring.keyshare.RequestAggrKeysharePacketAck.identity":
		return x.Identity != ""
	case "fairyring.keyshare.RequestAggrKeysharePacketAck.pubkey":
		return x.Pubkey != ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.RequestAggrKeysharePacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.RequestAggrKeysharePacketAck 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_RequestAggrKeysharePacketAck) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "fairyring.keyshare.RequestAggrKeysharePacketAck.identity":
		x.Identity = ""
	case "fairyring.keyshare.RequestAggrKeysharePacketAck.pubkey":
		x.Pubkey = ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.RequestAggrKeysharePacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.RequestAggrKeysharePacketAck 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_RequestAggrKeysharePacketAck) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "fairyring.keyshare.RequestAggrKeysharePacketAck.identity":
		value := x.Identity
		return protoreflect.ValueOfString(value)
	case "fairyring.keyshare.RequestAggrKeysharePacketAck.pubkey":
		value := x.Pubkey
		return protoreflect.ValueOfString(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.RequestAggrKeysharePacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.RequestAggrKeysharePacketAck 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_RequestAggrKeysharePacketAck) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "fairyring.keyshare.RequestAggrKeysharePacketAck.identity":
		x.Identity = value.Interface().(string)
	case "fairyring.keyshare.RequestAggrKeysharePacketAck.pubkey":
		x.Pubkey = value.Interface().(string)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.RequestAggrKeysharePacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.RequestAggrKeysharePacketAck 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_RequestAggrKeysharePacketAck) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "fairyring.keyshare.RequestAggrKeysharePacketAck.identity":
		panic(fmt.Errorf("field identity of message fairyring.keyshare.RequestAggrKeysharePacketAck is not mutable"))
	case "fairyring.keyshare.RequestAggrKeysharePacketAck.pubkey":
		panic(fmt.Errorf("field pubkey of message fairyring.keyshare.RequestAggrKeysharePacketAck is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.RequestAggrKeysharePacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.RequestAggrKeysharePacketAck 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_RequestAggrKeysharePacketAck) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "fairyring.keyshare.RequestAggrKeysharePacketAck.identity":
		return protoreflect.ValueOfString("")
	case "fairyring.keyshare.RequestAggrKeysharePacketAck.pubkey":
		return protoreflect.ValueOfString("")
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.RequestAggrKeysharePacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.RequestAggrKeysharePacketAck 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_RequestAggrKeysharePacketAck) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in fairyring.keyshare.RequestAggrKeysharePacketAck", 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_RequestAggrKeysharePacketAck) 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_RequestAggrKeysharePacketAck) 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_RequestAggrKeysharePacketAck) 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_RequestAggrKeysharePacketAck) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*RequestAggrKeysharePacketAck)
		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.Identity)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.Pubkey)
		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().(*RequestAggrKeysharePacketAck)
		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.Pubkey) > 0 {
			i -= len(x.Pubkey)
			copy(dAtA[i:], x.Pubkey)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Pubkey)))
			i--
			dAtA[i] = 0x12
		}
		if len(x.Identity) > 0 {
			i -= len(x.Identity)
			copy(dAtA[i:], x.Identity)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Identity)))
			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().(*RequestAggrKeysharePacketAck)
		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: RequestAggrKeysharePacketAck: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: RequestAggrKeysharePacketAck: 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 Identity", 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.Identity = 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 Pubkey", 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.Pubkey = 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_GetAggrKeysharePacketData          protoreflect.MessageDescriptor
	fd_GetAggrKeysharePacketData_identity protoreflect.FieldDescriptor
)

func init() {
	file_fairyring_keyshare_packet_proto_init()
	md_GetAggrKeysharePacketData = File_fairyring_keyshare_packet_proto.Messages().ByName("GetAggrKeysharePacketData")
	fd_GetAggrKeysharePacketData_identity = md_GetAggrKeysharePacketData.Fields().ByName("identity")
}

var _ protoreflect.Message = (*fastReflection_GetAggrKeysharePacketData)(nil)

type fastReflection_GetAggrKeysharePacketData GetAggrKeysharePacketData

func (x *GetAggrKeysharePacketData) ProtoReflect() protoreflect.Message {
	return (*fastReflection_GetAggrKeysharePacketData)(x)
}

func (x *GetAggrKeysharePacketData) slowProtoReflect() protoreflect.Message {
	mi := &file_fairyring_keyshare_packet_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_GetAggrKeysharePacketData_messageType fastReflection_GetAggrKeysharePacketData_messageType
var _ protoreflect.MessageType = fastReflection_GetAggrKeysharePacketData_messageType{}

type fastReflection_GetAggrKeysharePacketData_messageType struct{}

func (x fastReflection_GetAggrKeysharePacketData_messageType) Zero() protoreflect.Message {
	return (*fastReflection_GetAggrKeysharePacketData)(nil)
}
func (x fastReflection_GetAggrKeysharePacketData_messageType) New() protoreflect.Message {
	return new(fastReflection_GetAggrKeysharePacketData)
}
func (x fastReflection_GetAggrKeysharePacketData_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_GetAggrKeysharePacketData
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_GetAggrKeysharePacketData) Descriptor() protoreflect.MessageDescriptor {
	return md_GetAggrKeysharePacketData
}

// 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_GetAggrKeysharePacketData) Type() protoreflect.MessageType {
	return _fastReflection_GetAggrKeysharePacketData_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_GetAggrKeysharePacketData) New() protoreflect.Message {
	return new(fastReflection_GetAggrKeysharePacketData)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_GetAggrKeysharePacketData) Interface() protoreflect.ProtoMessage {
	return (*GetAggrKeysharePacketData)(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_GetAggrKeysharePacketData) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Identity != "" {
		value := protoreflect.ValueOfString(x.Identity)
		if !f(fd_GetAggrKeysharePacketData_identity, 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_GetAggrKeysharePacketData) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "fairyring.keyshare.GetAggrKeysharePacketData.identity":
		return x.Identity != ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.GetAggrKeysharePacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.GetAggrKeysharePacketData 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_GetAggrKeysharePacketData) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "fairyring.keyshare.GetAggrKeysharePacketData.identity":
		x.Identity = ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.GetAggrKeysharePacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.GetAggrKeysharePacketData 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_GetAggrKeysharePacketData) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "fairyring.keyshare.GetAggrKeysharePacketData.identity":
		value := x.Identity
		return protoreflect.ValueOfString(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.GetAggrKeysharePacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.GetAggrKeysharePacketData 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_GetAggrKeysharePacketData) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "fairyring.keyshare.GetAggrKeysharePacketData.identity":
		x.Identity = value.Interface().(string)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.GetAggrKeysharePacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.GetAggrKeysharePacketData 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_GetAggrKeysharePacketData) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "fairyring.keyshare.GetAggrKeysharePacketData.identity":
		panic(fmt.Errorf("field identity of message fairyring.keyshare.GetAggrKeysharePacketData is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.GetAggrKeysharePacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.GetAggrKeysharePacketData 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_GetAggrKeysharePacketData) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "fairyring.keyshare.GetAggrKeysharePacketData.identity":
		return protoreflect.ValueOfString("")
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.GetAggrKeysharePacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.GetAggrKeysharePacketData 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_GetAggrKeysharePacketData) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in fairyring.keyshare.GetAggrKeysharePacketData", 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_GetAggrKeysharePacketData) 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_GetAggrKeysharePacketData) 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_GetAggrKeysharePacketData) 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_GetAggrKeysharePacketData) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*GetAggrKeysharePacketData)
		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.Identity)
		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().(*GetAggrKeysharePacketData)
		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.Identity) > 0 {
			i -= len(x.Identity)
			copy(dAtA[i:], x.Identity)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Identity)))
			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().(*GetAggrKeysharePacketData)
		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: GetAggrKeysharePacketData: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GetAggrKeysharePacketData: 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 Identity", 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.Identity = 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_GetAggrKeysharePacketAck protoreflect.MessageDescriptor
)

func init() {
	file_fairyring_keyshare_packet_proto_init()
	md_GetAggrKeysharePacketAck = File_fairyring_keyshare_packet_proto.Messages().ByName("GetAggrKeysharePacketAck")
}

var _ protoreflect.Message = (*fastReflection_GetAggrKeysharePacketAck)(nil)

type fastReflection_GetAggrKeysharePacketAck GetAggrKeysharePacketAck

func (x *GetAggrKeysharePacketAck) ProtoReflect() protoreflect.Message {
	return (*fastReflection_GetAggrKeysharePacketAck)(x)
}

func (x *GetAggrKeysharePacketAck) slowProtoReflect() protoreflect.Message {
	mi := &file_fairyring_keyshare_packet_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_GetAggrKeysharePacketAck_messageType fastReflection_GetAggrKeysharePacketAck_messageType
var _ protoreflect.MessageType = fastReflection_GetAggrKeysharePacketAck_messageType{}

type fastReflection_GetAggrKeysharePacketAck_messageType struct{}

func (x fastReflection_GetAggrKeysharePacketAck_messageType) Zero() protoreflect.Message {
	return (*fastReflection_GetAggrKeysharePacketAck)(nil)
}
func (x fastReflection_GetAggrKeysharePacketAck_messageType) New() protoreflect.Message {
	return new(fastReflection_GetAggrKeysharePacketAck)
}
func (x fastReflection_GetAggrKeysharePacketAck_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_GetAggrKeysharePacketAck
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_GetAggrKeysharePacketAck) Descriptor() protoreflect.MessageDescriptor {
	return md_GetAggrKeysharePacketAck
}

// 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_GetAggrKeysharePacketAck) Type() protoreflect.MessageType {
	return _fastReflection_GetAggrKeysharePacketAck_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_GetAggrKeysharePacketAck) New() protoreflect.Message {
	return new(fastReflection_GetAggrKeysharePacketAck)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_GetAggrKeysharePacketAck) Interface() protoreflect.ProtoMessage {
	return (*GetAggrKeysharePacketAck)(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_GetAggrKeysharePacketAck) 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_GetAggrKeysharePacketAck) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.GetAggrKeysharePacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.GetAggrKeysharePacketAck 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_GetAggrKeysharePacketAck) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.GetAggrKeysharePacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.GetAggrKeysharePacketAck 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_GetAggrKeysharePacketAck) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.GetAggrKeysharePacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.GetAggrKeysharePacketAck 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_GetAggrKeysharePacketAck) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.GetAggrKeysharePacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.GetAggrKeysharePacketAck 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_GetAggrKeysharePacketAck) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.GetAggrKeysharePacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.GetAggrKeysharePacketAck 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_GetAggrKeysharePacketAck) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.GetAggrKeysharePacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.GetAggrKeysharePacketAck 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_GetAggrKeysharePacketAck) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in fairyring.keyshare.GetAggrKeysharePacketAck", 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_GetAggrKeysharePacketAck) 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_GetAggrKeysharePacketAck) 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_GetAggrKeysharePacketAck) 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_GetAggrKeysharePacketAck) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*GetAggrKeysharePacketAck)
		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().(*GetAggrKeysharePacketAck)
		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().(*GetAggrKeysharePacketAck)
		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: GetAggrKeysharePacketAck: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: GetAggrKeysharePacketAck: 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_AggrKeyshareDataPacketData               protoreflect.MessageDescriptor
	fd_AggrKeyshareDataPacketData_identity      protoreflect.FieldDescriptor
	fd_AggrKeyshareDataPacketData_pubkey        protoreflect.FieldDescriptor
	fd_AggrKeyshareDataPacketData_aggr_keyshare protoreflect.FieldDescriptor
	fd_AggrKeyshareDataPacketData_aggr_height   protoreflect.FieldDescriptor
	fd_AggrKeyshareDataPacketData_proposal_id   protoreflect.FieldDescriptor
	fd_AggrKeyshareDataPacketData_request_id    protoreflect.FieldDescriptor
	fd_AggrKeyshareDataPacketData_retries       protoreflect.FieldDescriptor
)

func init() {
	file_fairyring_keyshare_packet_proto_init()
	md_AggrKeyshareDataPacketData = File_fairyring_keyshare_packet_proto.Messages().ByName("AggrKeyshareDataPacketData")
	fd_AggrKeyshareDataPacketData_identity = md_AggrKeyshareDataPacketData.Fields().ByName("identity")
	fd_AggrKeyshareDataPacketData_pubkey = md_AggrKeyshareDataPacketData.Fields().ByName("pubkey")
	fd_AggrKeyshareDataPacketData_aggr_keyshare = md_AggrKeyshareDataPacketData.Fields().ByName("aggr_keyshare")
	fd_AggrKeyshareDataPacketData_aggr_height = md_AggrKeyshareDataPacketData.Fields().ByName("aggr_height")
	fd_AggrKeyshareDataPacketData_proposal_id = md_AggrKeyshareDataPacketData.Fields().ByName("proposal_id")
	fd_AggrKeyshareDataPacketData_request_id = md_AggrKeyshareDataPacketData.Fields().ByName("request_id")
	fd_AggrKeyshareDataPacketData_retries = md_AggrKeyshareDataPacketData.Fields().ByName("retries")
}

var _ protoreflect.Message = (*fastReflection_AggrKeyshareDataPacketData)(nil)

type fastReflection_AggrKeyshareDataPacketData AggrKeyshareDataPacketData

func (x *AggrKeyshareDataPacketData) ProtoReflect() protoreflect.Message {
	return (*fastReflection_AggrKeyshareDataPacketData)(x)
}

func (x *AggrKeyshareDataPacketData) slowProtoReflect() protoreflect.Message {
	mi := &file_fairyring_keyshare_packet_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_AggrKeyshareDataPacketData_messageType fastReflection_AggrKeyshareDataPacketData_messageType
var _ protoreflect.MessageType = fastReflection_AggrKeyshareDataPacketData_messageType{}

type fastReflection_AggrKeyshareDataPacketData_messageType struct{}

func (x fastReflection_AggrKeyshareDataPacketData_messageType) Zero() protoreflect.Message {
	return (*fastReflection_AggrKeyshareDataPacketData)(nil)
}
func (x fastReflection_AggrKeyshareDataPacketData_messageType) New() protoreflect.Message {
	return new(fastReflection_AggrKeyshareDataPacketData)
}
func (x fastReflection_AggrKeyshareDataPacketData_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_AggrKeyshareDataPacketData
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_AggrKeyshareDataPacketData) Descriptor() protoreflect.MessageDescriptor {
	return md_AggrKeyshareDataPacketData
}

// 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_AggrKeyshareDataPacketData) Type() protoreflect.MessageType {
	return _fastReflection_AggrKeyshareDataPacketData_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_AggrKeyshareDataPacketData) New() protoreflect.Message {
	return new(fastReflection_AggrKeyshareDataPacketData)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_AggrKeyshareDataPacketData) Interface() protoreflect.ProtoMessage {
	return (*AggrKeyshareDataPacketData)(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_AggrKeyshareDataPacketData) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Identity != "" {
		value := protoreflect.ValueOfString(x.Identity)
		if !f(fd_AggrKeyshareDataPacketData_identity, value) {
			return
		}
	}
	if x.Pubkey != "" {
		value := protoreflect.ValueOfString(x.Pubkey)
		if !f(fd_AggrKeyshareDataPacketData_pubkey, value) {
			return
		}
	}
	if x.AggrKeyshare != "" {
		value := protoreflect.ValueOfString(x.AggrKeyshare)
		if !f(fd_AggrKeyshareDataPacketData_aggr_keyshare, value) {
			return
		}
	}
	if x.AggrHeight != "" {
		value := protoreflect.ValueOfString(x.AggrHeight)
		if !f(fd_AggrKeyshareDataPacketData_aggr_height, value) {
			return
		}
	}
	if x.ProposalId != "" {
		value := protoreflect.ValueOfString(x.ProposalId)
		if !f(fd_AggrKeyshareDataPacketData_proposal_id, value) {
			return
		}
	}
	if x.RequestId != "" {
		value := protoreflect.ValueOfString(x.RequestId)
		if !f(fd_AggrKeyshareDataPacketData_request_id, value) {
			return
		}
	}
	if x.Retries != uint64(0) {
		value := protoreflect.ValueOfUint64(x.Retries)
		if !f(fd_AggrKeyshareDataPacketData_retries, 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_AggrKeyshareDataPacketData) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "fairyring.keyshare.AggrKeyshareDataPacketData.identity":
		return x.Identity != ""
	case "fairyring.keyshare.AggrKeyshareDataPacketData.pubkey":
		return x.Pubkey != ""
	case "fairyring.keyshare.AggrKeyshareDataPacketData.aggr_keyshare":
		return x.AggrKeyshare != ""
	case "fairyring.keyshare.AggrKeyshareDataPacketData.aggr_height":
		return x.AggrHeight != ""
	case "fairyring.keyshare.AggrKeyshareDataPacketData.proposal_id":
		return x.ProposalId != ""
	case "fairyring.keyshare.AggrKeyshareDataPacketData.request_id":
		return x.RequestId != ""
	case "fairyring.keyshare.AggrKeyshareDataPacketData.retries":
		return x.Retries != uint64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.AggrKeyshareDataPacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.AggrKeyshareDataPacketData 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_AggrKeyshareDataPacketData) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "fairyring.keyshare.AggrKeyshareDataPacketData.identity":
		x.Identity = ""
	case "fairyring.keyshare.AggrKeyshareDataPacketData.pubkey":
		x.Pubkey = ""
	case "fairyring.keyshare.AggrKeyshareDataPacketData.aggr_keyshare":
		x.AggrKeyshare = ""
	case "fairyring.keyshare.AggrKeyshareDataPacketData.aggr_height":
		x.AggrHeight = ""
	case "fairyring.keyshare.AggrKeyshareDataPacketData.proposal_id":
		x.ProposalId = ""
	case "fairyring.keyshare.AggrKeyshareDataPacketData.request_id":
		x.RequestId = ""
	case "fairyring.keyshare.AggrKeyshareDataPacketData.retries":
		x.Retries = uint64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.AggrKeyshareDataPacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.AggrKeyshareDataPacketData 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_AggrKeyshareDataPacketData) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "fairyring.keyshare.AggrKeyshareDataPacketData.identity":
		value := x.Identity
		return protoreflect.ValueOfString(value)
	case "fairyring.keyshare.AggrKeyshareDataPacketData.pubkey":
		value := x.Pubkey
		return protoreflect.ValueOfString(value)
	case "fairyring.keyshare.AggrKeyshareDataPacketData.aggr_keyshare":
		value := x.AggrKeyshare
		return protoreflect.ValueOfString(value)
	case "fairyring.keyshare.AggrKeyshareDataPacketData.aggr_height":
		value := x.AggrHeight
		return protoreflect.ValueOfString(value)
	case "fairyring.keyshare.AggrKeyshareDataPacketData.proposal_id":
		value := x.ProposalId
		return protoreflect.ValueOfString(value)
	case "fairyring.keyshare.AggrKeyshareDataPacketData.request_id":
		value := x.RequestId
		return protoreflect.ValueOfString(value)
	case "fairyring.keyshare.AggrKeyshareDataPacketData.retries":
		value := x.Retries
		return protoreflect.ValueOfUint64(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.AggrKeyshareDataPacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.AggrKeyshareDataPacketData 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_AggrKeyshareDataPacketData) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "fairyring.keyshare.AggrKeyshareDataPacketData.identity":
		x.Identity = value.Interface().(string)
	case "fairyring.keyshare.AggrKeyshareDataPacketData.pubkey":
		x.Pubkey = value.Interface().(string)
	case "fairyring.keyshare.AggrKeyshareDataPacketData.aggr_keyshare":
		x.AggrKeyshare = value.Interface().(string)
	case "fairyring.keyshare.AggrKeyshareDataPacketData.aggr_height":
		x.AggrHeight = value.Interface().(string)
	case "fairyring.keyshare.AggrKeyshareDataPacketData.proposal_id":
		x.ProposalId = value.Interface().(string)
	case "fairyring.keyshare.AggrKeyshareDataPacketData.request_id":
		x.RequestId = value.Interface().(string)
	case "fairyring.keyshare.AggrKeyshareDataPacketData.retries":
		x.Retries = value.Uint()
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.AggrKeyshareDataPacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.AggrKeyshareDataPacketData 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_AggrKeyshareDataPacketData) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "fairyring.keyshare.AggrKeyshareDataPacketData.identity":
		panic(fmt.Errorf("field identity of message fairyring.keyshare.AggrKeyshareDataPacketData is not mutable"))
	case "fairyring.keyshare.AggrKeyshareDataPacketData.pubkey":
		panic(fmt.Errorf("field pubkey of message fairyring.keyshare.AggrKeyshareDataPacketData is not mutable"))
	case "fairyring.keyshare.AggrKeyshareDataPacketData.aggr_keyshare":
		panic(fmt.Errorf("field aggr_keyshare of message fairyring.keyshare.AggrKeyshareDataPacketData is not mutable"))
	case "fairyring.keyshare.AggrKeyshareDataPacketData.aggr_height":
		panic(fmt.Errorf("field aggr_height of message fairyring.keyshare.AggrKeyshareDataPacketData is not mutable"))
	case "fairyring.keyshare.AggrKeyshareDataPacketData.proposal_id":
		panic(fmt.Errorf("field proposal_id of message fairyring.keyshare.AggrKeyshareDataPacketData is not mutable"))
	case "fairyring.keyshare.AggrKeyshareDataPacketData.request_id":
		panic(fmt.Errorf("field request_id of message fairyring.keyshare.AggrKeyshareDataPacketData is not mutable"))
	case "fairyring.keyshare.AggrKeyshareDataPacketData.retries":
		panic(fmt.Errorf("field retries of message fairyring.keyshare.AggrKeyshareDataPacketData is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.AggrKeyshareDataPacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.AggrKeyshareDataPacketData 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_AggrKeyshareDataPacketData) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "fairyring.keyshare.AggrKeyshareDataPacketData.identity":
		return protoreflect.ValueOfString("")
	case "fairyring.keyshare.AggrKeyshareDataPacketData.pubkey":
		return protoreflect.ValueOfString("")
	case "fairyring.keyshare.AggrKeyshareDataPacketData.aggr_keyshare":
		return protoreflect.ValueOfString("")
	case "fairyring.keyshare.AggrKeyshareDataPacketData.aggr_height":
		return protoreflect.ValueOfString("")
	case "fairyring.keyshare.AggrKeyshareDataPacketData.proposal_id":
		return protoreflect.ValueOfString("")
	case "fairyring.keyshare.AggrKeyshareDataPacketData.request_id":
		return protoreflect.ValueOfString("")
	case "fairyring.keyshare.AggrKeyshareDataPacketData.retries":
		return protoreflect.ValueOfUint64(uint64(0))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.AggrKeyshareDataPacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.AggrKeyshareDataPacketData 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_AggrKeyshareDataPacketData) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in fairyring.keyshare.AggrKeyshareDataPacketData", 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_AggrKeyshareDataPacketData) 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_AggrKeyshareDataPacketData) 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_AggrKeyshareDataPacketData) 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_AggrKeyshareDataPacketData) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*AggrKeyshareDataPacketData)
		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.Identity)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.Pubkey)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.AggrKeyshare)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.AggrHeight)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.ProposalId)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.RequestId)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Retries != 0 {
			n += 1 + runtime.Sov(uint64(x.Retries))
		}
		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().(*AggrKeyshareDataPacketData)
		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.Retries != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Retries))
			i--
			dAtA[i] = 0x38
		}
		if len(x.RequestId) > 0 {
			i -= len(x.RequestId)
			copy(dAtA[i:], x.RequestId)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RequestId)))
			i--
			dAtA[i] = 0x32
		}
		if len(x.ProposalId) > 0 {
			i -= len(x.ProposalId)
			copy(dAtA[i:], x.ProposalId)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ProposalId)))
			i--
			dAtA[i] = 0x2a
		}
		if len(x.AggrHeight) > 0 {
			i -= len(x.AggrHeight)
			copy(dAtA[i:], x.AggrHeight)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.AggrHeight)))
			i--
			dAtA[i] = 0x22
		}
		if len(x.AggrKeyshare) > 0 {
			i -= len(x.AggrKeyshare)
			copy(dAtA[i:], x.AggrKeyshare)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.AggrKeyshare)))
			i--
			dAtA[i] = 0x1a
		}
		if len(x.Pubkey) > 0 {
			i -= len(x.Pubkey)
			copy(dAtA[i:], x.Pubkey)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Pubkey)))
			i--
			dAtA[i] = 0x12
		}
		if len(x.Identity) > 0 {
			i -= len(x.Identity)
			copy(dAtA[i:], x.Identity)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Identity)))
			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().(*AggrKeyshareDataPacketData)
		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: AggrKeyshareDataPacketData: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: AggrKeyshareDataPacketData: 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 Identity", 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.Identity = 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 Pubkey", 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.Pubkey = 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 AggrKeyshare", 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.AggrKeyshare = 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 AggrHeight", 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.AggrHeight = 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 ProposalId", 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.ProposalId = 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 RequestId", 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.RequestId = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 7:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Retries", wireType)
				}
				x.Retries = 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.Retries |= 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_AggrKeyshareDataPacketAck protoreflect.MessageDescriptor
)

func init() {
	file_fairyring_keyshare_packet_proto_init()
	md_AggrKeyshareDataPacketAck = File_fairyring_keyshare_packet_proto.Messages().ByName("AggrKeyshareDataPacketAck")
}

var _ protoreflect.Message = (*fastReflection_AggrKeyshareDataPacketAck)(nil)

type fastReflection_AggrKeyshareDataPacketAck AggrKeyshareDataPacketAck

func (x *AggrKeyshareDataPacketAck) ProtoReflect() protoreflect.Message {
	return (*fastReflection_AggrKeyshareDataPacketAck)(x)
}

func (x *AggrKeyshareDataPacketAck) slowProtoReflect() protoreflect.Message {
	mi := &file_fairyring_keyshare_packet_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_AggrKeyshareDataPacketAck_messageType fastReflection_AggrKeyshareDataPacketAck_messageType
var _ protoreflect.MessageType = fastReflection_AggrKeyshareDataPacketAck_messageType{}

type fastReflection_AggrKeyshareDataPacketAck_messageType struct{}

func (x fastReflection_AggrKeyshareDataPacketAck_messageType) Zero() protoreflect.Message {
	return (*fastReflection_AggrKeyshareDataPacketAck)(nil)
}
func (x fastReflection_AggrKeyshareDataPacketAck_messageType) New() protoreflect.Message {
	return new(fastReflection_AggrKeyshareDataPacketAck)
}
func (x fastReflection_AggrKeyshareDataPacketAck_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_AggrKeyshareDataPacketAck
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_AggrKeyshareDataPacketAck) Descriptor() protoreflect.MessageDescriptor {
	return md_AggrKeyshareDataPacketAck
}

// 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_AggrKeyshareDataPacketAck) Type() protoreflect.MessageType {
	return _fastReflection_AggrKeyshareDataPacketAck_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_AggrKeyshareDataPacketAck) New() protoreflect.Message {
	return new(fastReflection_AggrKeyshareDataPacketAck)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_AggrKeyshareDataPacketAck) Interface() protoreflect.ProtoMessage {
	return (*AggrKeyshareDataPacketAck)(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_AggrKeyshareDataPacketAck) 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_AggrKeyshareDataPacketAck) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.AggrKeyshareDataPacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.AggrKeyshareDataPacketAck 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_AggrKeyshareDataPacketAck) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.AggrKeyshareDataPacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.AggrKeyshareDataPacketAck 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_AggrKeyshareDataPacketAck) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.AggrKeyshareDataPacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.AggrKeyshareDataPacketAck 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_AggrKeyshareDataPacketAck) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.AggrKeyshareDataPacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.AggrKeyshareDataPacketAck 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_AggrKeyshareDataPacketAck) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.AggrKeyshareDataPacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.AggrKeyshareDataPacketAck 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_AggrKeyshareDataPacketAck) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.AggrKeyshareDataPacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.AggrKeyshareDataPacketAck 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_AggrKeyshareDataPacketAck) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in fairyring.keyshare.AggrKeyshareDataPacketAck", 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_AggrKeyshareDataPacketAck) 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_AggrKeyshareDataPacketAck) 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_AggrKeyshareDataPacketAck) 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_AggrKeyshareDataPacketAck) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*AggrKeyshareDataPacketAck)
		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().(*AggrKeyshareDataPacketAck)
		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().(*AggrKeyshareDataPacketAck)
		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: AggrKeyshareDataPacketAck: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: AggrKeyshareDataPacketAck: 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_CurrentKeysPacketData protoreflect.MessageDescriptor
)

func init() {
	file_fairyring_keyshare_packet_proto_init()
	md_CurrentKeysPacketData = File_fairyring_keyshare_packet_proto.Messages().ByName("CurrentKeysPacketData")
}

var _ protoreflect.Message = (*fastReflection_CurrentKeysPacketData)(nil)

type fastReflection_CurrentKeysPacketData CurrentKeysPacketData

func (x *CurrentKeysPacketData) ProtoReflect() protoreflect.Message {
	return (*fastReflection_CurrentKeysPacketData)(x)
}

func (x *CurrentKeysPacketData) slowProtoReflect() protoreflect.Message {
	mi := &file_fairyring_keyshare_packet_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_CurrentKeysPacketData_messageType fastReflection_CurrentKeysPacketData_messageType
var _ protoreflect.MessageType = fastReflection_CurrentKeysPacketData_messageType{}

type fastReflection_CurrentKeysPacketData_messageType struct{}

func (x fastReflection_CurrentKeysPacketData_messageType) Zero() protoreflect.Message {
	return (*fastReflection_CurrentKeysPacketData)(nil)
}
func (x fastReflection_CurrentKeysPacketData_messageType) New() protoreflect.Message {
	return new(fastReflection_CurrentKeysPacketData)
}
func (x fastReflection_CurrentKeysPacketData_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_CurrentKeysPacketData
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_CurrentKeysPacketData) Descriptor() protoreflect.MessageDescriptor {
	return md_CurrentKeysPacketData
}

// 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_CurrentKeysPacketData) Type() protoreflect.MessageType {
	return _fastReflection_CurrentKeysPacketData_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_CurrentKeysPacketData) New() protoreflect.Message {
	return new(fastReflection_CurrentKeysPacketData)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_CurrentKeysPacketData) Interface() protoreflect.ProtoMessage {
	return (*CurrentKeysPacketData)(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_CurrentKeysPacketData) 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_CurrentKeysPacketData) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.CurrentKeysPacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.CurrentKeysPacketData 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_CurrentKeysPacketData) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.CurrentKeysPacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.CurrentKeysPacketData 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_CurrentKeysPacketData) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.CurrentKeysPacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.CurrentKeysPacketData 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_CurrentKeysPacketData) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.CurrentKeysPacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.CurrentKeysPacketData 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_CurrentKeysPacketData) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.CurrentKeysPacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.CurrentKeysPacketData 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_CurrentKeysPacketData) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.CurrentKeysPacketData"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.CurrentKeysPacketData 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_CurrentKeysPacketData) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in fairyring.keyshare.CurrentKeysPacketData", 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_CurrentKeysPacketData) 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_CurrentKeysPacketData) 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_CurrentKeysPacketData) 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_CurrentKeysPacketData) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*CurrentKeysPacketData)
		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().(*CurrentKeysPacketData)
		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().(*CurrentKeysPacketData)
		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: CurrentKeysPacketData: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: CurrentKeysPacketData: 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_CurrentKeysPacketAck           protoreflect.MessageDescriptor
	fd_CurrentKeysPacketAck_activeKey protoreflect.FieldDescriptor
	fd_CurrentKeysPacketAck_queuedKey protoreflect.FieldDescriptor
)

func init() {
	file_fairyring_keyshare_packet_proto_init()
	md_CurrentKeysPacketAck = File_fairyring_keyshare_packet_proto.Messages().ByName("CurrentKeysPacketAck")
	fd_CurrentKeysPacketAck_activeKey = md_CurrentKeysPacketAck.Fields().ByName("activeKey")
	fd_CurrentKeysPacketAck_queuedKey = md_CurrentKeysPacketAck.Fields().ByName("queuedKey")
}

var _ protoreflect.Message = (*fastReflection_CurrentKeysPacketAck)(nil)

type fastReflection_CurrentKeysPacketAck CurrentKeysPacketAck

func (x *CurrentKeysPacketAck) ProtoReflect() protoreflect.Message {
	return (*fastReflection_CurrentKeysPacketAck)(x)
}

func (x *CurrentKeysPacketAck) slowProtoReflect() protoreflect.Message {
	mi := &file_fairyring_keyshare_packet_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_CurrentKeysPacketAck_messageType fastReflection_CurrentKeysPacketAck_messageType
var _ protoreflect.MessageType = fastReflection_CurrentKeysPacketAck_messageType{}

type fastReflection_CurrentKeysPacketAck_messageType struct{}

func (x fastReflection_CurrentKeysPacketAck_messageType) Zero() protoreflect.Message {
	return (*fastReflection_CurrentKeysPacketAck)(nil)
}
func (x fastReflection_CurrentKeysPacketAck_messageType) New() protoreflect.Message {
	return new(fastReflection_CurrentKeysPacketAck)
}
func (x fastReflection_CurrentKeysPacketAck_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_CurrentKeysPacketAck
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_CurrentKeysPacketAck) Descriptor() protoreflect.MessageDescriptor {
	return md_CurrentKeysPacketAck
}

// 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_CurrentKeysPacketAck) Type() protoreflect.MessageType {
	return _fastReflection_CurrentKeysPacketAck_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_CurrentKeysPacketAck) New() protoreflect.Message {
	return new(fastReflection_CurrentKeysPacketAck)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_CurrentKeysPacketAck) Interface() protoreflect.ProtoMessage {
	return (*CurrentKeysPacketAck)(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_CurrentKeysPacketAck) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.ActiveKey != nil {
		value := protoreflect.ValueOfMessage(x.ActiveKey.ProtoReflect())
		if !f(fd_CurrentKeysPacketAck_activeKey, value) {
			return
		}
	}
	if x.QueuedKey != nil {
		value := protoreflect.ValueOfMessage(x.QueuedKey.ProtoReflect())
		if !f(fd_CurrentKeysPacketAck_queuedKey, 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_CurrentKeysPacketAck) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "fairyring.keyshare.CurrentKeysPacketAck.activeKey":
		return x.ActiveKey != nil
	case "fairyring.keyshare.CurrentKeysPacketAck.queuedKey":
		return x.QueuedKey != nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.CurrentKeysPacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.CurrentKeysPacketAck 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_CurrentKeysPacketAck) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "fairyring.keyshare.CurrentKeysPacketAck.activeKey":
		x.ActiveKey = nil
	case "fairyring.keyshare.CurrentKeysPacketAck.queuedKey":
		x.QueuedKey = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.CurrentKeysPacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.CurrentKeysPacketAck 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_CurrentKeysPacketAck) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "fairyring.keyshare.CurrentKeysPacketAck.activeKey":
		value := x.ActiveKey
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "fairyring.keyshare.CurrentKeysPacketAck.queuedKey":
		value := x.QueuedKey
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.CurrentKeysPacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.CurrentKeysPacketAck 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_CurrentKeysPacketAck) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "fairyring.keyshare.CurrentKeysPacketAck.activeKey":
		x.ActiveKey = value.Message().Interface().(*common.ActivePublicKey)
	case "fairyring.keyshare.CurrentKeysPacketAck.queuedKey":
		x.QueuedKey = value.Message().Interface().(*common.QueuedPublicKey)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.CurrentKeysPacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.CurrentKeysPacketAck 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_CurrentKeysPacketAck) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "fairyring.keyshare.CurrentKeysPacketAck.activeKey":
		if x.ActiveKey == nil {
			x.ActiveKey = new(common.ActivePublicKey)
		}
		return protoreflect.ValueOfMessage(x.ActiveKey.ProtoReflect())
	case "fairyring.keyshare.CurrentKeysPacketAck.queuedKey":
		if x.QueuedKey == nil {
			x.QueuedKey = new(common.QueuedPublicKey)
		}
		return protoreflect.ValueOfMessage(x.QueuedKey.ProtoReflect())
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.CurrentKeysPacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.CurrentKeysPacketAck 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_CurrentKeysPacketAck) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "fairyring.keyshare.CurrentKeysPacketAck.activeKey":
		m := new(common.ActivePublicKey)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "fairyring.keyshare.CurrentKeysPacketAck.queuedKey":
		m := new(common.QueuedPublicKey)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: fairyring.keyshare.CurrentKeysPacketAck"))
		}
		panic(fmt.Errorf("message fairyring.keyshare.CurrentKeysPacketAck 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_CurrentKeysPacketAck) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in fairyring.keyshare.CurrentKeysPacketAck", 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_CurrentKeysPacketAck) 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_CurrentKeysPacketAck) 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_CurrentKeysPacketAck) 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_CurrentKeysPacketAck) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*CurrentKeysPacketAck)
		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.ActiveKey != nil {
			l = options.Size(x.ActiveKey)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.QueuedKey != nil {
			l = options.Size(x.QueuedKey)
			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().(*CurrentKeysPacketAck)
		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.QueuedKey != nil {
			encoded, err := options.Marshal(x.QueuedKey)
			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.ActiveKey != nil {
			encoded, err := options.Marshal(x.ActiveKey)
			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().(*CurrentKeysPacketAck)
		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: CurrentKeysPacketAck: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: CurrentKeysPacketAck: 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 ActiveKey", 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.ActiveKey == nil {
					x.ActiveKey = &common.ActivePublicKey{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ActiveKey); 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 QueuedKey", 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.QueuedKey == nil {
					x.QueuedKey = &common.QueuedPublicKey{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.QueuedKey); 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: fairyring/keyshare/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)
)

type KeysharePacketData struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Types that are assignable to Packet:
	//
	//	*KeysharePacketData_NoData
	//	*KeysharePacketData_RequestAggrKeysharePacket
	//	*KeysharePacketData_GetAggrKeysharePacket
	//	*KeysharePacketData_AggrKeyshareDataPacket
	//	*KeysharePacketData_CurrentKeysPacket
	Packet isKeysharePacketData_Packet `protobuf_oneof:"packet"`
}

func (x *KeysharePacketData) Reset() {
	*x = KeysharePacketData{}
	if protoimpl.UnsafeEnabled {
		mi := &file_fairyring_keyshare_packet_proto_msgTypes[0]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *KeysharePacketData) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KeysharePacketData) ProtoMessage() {}

// Deprecated: Use KeysharePacketData.ProtoReflect.Descriptor instead.
func (*KeysharePacketData) Descriptor() ([]byte, []int) {
	return file_fairyring_keyshare_packet_proto_rawDescGZIP(), []int{0}
}

func (x *KeysharePacketData) GetPacket() isKeysharePacketData_Packet {
	if x != nil {
		return x.Packet
	}
	return nil
}

func (x *KeysharePacketData) GetNoData() *NoData {
	if x, ok := x.GetPacket().(*KeysharePacketData_NoData); ok {
		return x.NoData
	}
	return nil
}

func (x *KeysharePacketData) GetRequestAggrKeysharePacket() *RequestAggrKeysharePacketData {
	if x, ok := x.GetPacket().(*KeysharePacketData_RequestAggrKeysharePacket); ok {
		return x.RequestAggrKeysharePacket
	}
	return nil
}

func (x *KeysharePacketData) GetGetAggrKeysharePacket() *GetAggrKeysharePacketData {
	if x, ok := x.GetPacket().(*KeysharePacketData_GetAggrKeysharePacket); ok {
		return x.GetAggrKeysharePacket
	}
	return nil
}

func (x *KeysharePacketData) GetAggrKeyshareDataPacket() *AggrKeyshareDataPacketData {
	if x, ok := x.GetPacket().(*KeysharePacketData_AggrKeyshareDataPacket); ok {
		return x.AggrKeyshareDataPacket
	}
	return nil
}

func (x *KeysharePacketData) GetCurrentKeysPacket() *CurrentKeysPacketData {
	if x, ok := x.GetPacket().(*KeysharePacketData_CurrentKeysPacket); ok {
		return x.CurrentKeysPacket
	}
	return nil
}

type isKeysharePacketData_Packet interface {
	isKeysharePacketData_Packet()
}

type KeysharePacketData_NoData struct {
	NoData *NoData `protobuf:"bytes,1,opt,name=noData,proto3,oneof"`
}

type KeysharePacketData_RequestAggrKeysharePacket struct {
	RequestAggrKeysharePacket *RequestAggrKeysharePacketData `protobuf:"bytes,2,opt,name=requestAggrKeysharePacket,proto3,oneof"`
}

type KeysharePacketData_GetAggrKeysharePacket struct {
	GetAggrKeysharePacket *GetAggrKeysharePacketData `protobuf:"bytes,3,opt,name=getAggrKeysharePacket,proto3,oneof"`
}

type KeysharePacketData_AggrKeyshareDataPacket struct {
	AggrKeyshareDataPacket *AggrKeyshareDataPacketData `protobuf:"bytes,4,opt,name=aggrKeyshareDataPacket,proto3,oneof"`
}

type KeysharePacketData_CurrentKeysPacket struct {
	CurrentKeysPacket *CurrentKeysPacketData `protobuf:"bytes,5,opt,name=currentKeysPacket,proto3,oneof"`
}

func (*KeysharePacketData_NoData) isKeysharePacketData_Packet() {}

func (*KeysharePacketData_RequestAggrKeysharePacket) isKeysharePacketData_Packet() {}

func (*KeysharePacketData_GetAggrKeysharePacket) isKeysharePacketData_Packet() {}

func (*KeysharePacketData_AggrKeyshareDataPacket) isKeysharePacketData_Packet() {}

func (*KeysharePacketData_CurrentKeysPacket) isKeysharePacketData_Packet() {}

type NoData struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
}

func (x *NoData) Reset() {
	*x = NoData{}
	if protoimpl.UnsafeEnabled {
		mi := &file_fairyring_keyshare_packet_proto_msgTypes[1]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *NoData) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*NoData) ProtoMessage() {}

// Deprecated: Use NoData.ProtoReflect.Descriptor instead.
func (*NoData) Descriptor() ([]byte, []int) {
	return file_fairyring_keyshare_packet_proto_rawDescGZIP(), []int{1}
}

// RequestAggrKeysharePacketData defines a struct for the packet payload
type RequestAggrKeysharePacketData struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Requester string `protobuf:"bytes,1,opt,name=requester,proto3" json:"requester,omitempty"`
	// Types that are assignable to Id:
	//
	//	*RequestAggrKeysharePacketData_ProposalId
	//	*RequestAggrKeysharePacketData_RequestId
	Id isRequestAggrKeysharePacketData_Id `protobuf_oneof:"id"`
}

func (x *RequestAggrKeysharePacketData) Reset() {
	*x = RequestAggrKeysharePacketData{}
	if protoimpl.UnsafeEnabled {
		mi := &file_fairyring_keyshare_packet_proto_msgTypes[2]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *RequestAggrKeysharePacketData) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RequestAggrKeysharePacketData) ProtoMessage() {}

// Deprecated: Use RequestAggrKeysharePacketData.ProtoReflect.Descriptor instead.
func (*RequestAggrKeysharePacketData) Descriptor() ([]byte, []int) {
	return file_fairyring_keyshare_packet_proto_rawDescGZIP(), []int{2}
}

func (x *RequestAggrKeysharePacketData) GetRequester() string {
	if x != nil {
		return x.Requester
	}
	return ""
}

func (x *RequestAggrKeysharePacketData) GetId() isRequestAggrKeysharePacketData_Id {
	if x != nil {
		return x.Id
	}
	return nil
}

func (x *RequestAggrKeysharePacketData) GetProposalId() string {
	if x, ok := x.GetId().(*RequestAggrKeysharePacketData_ProposalId); ok {
		return x.ProposalId
	}
	return ""
}

func (x *RequestAggrKeysharePacketData) GetRequestId() string {
	if x, ok := x.GetId().(*RequestAggrKeysharePacketData_RequestId); ok {
		return x.RequestId
	}
	return ""
}

type isRequestAggrKeysharePacketData_Id interface {
	isRequestAggrKeysharePacketData_Id()
}

type RequestAggrKeysharePacketData_ProposalId struct {
	ProposalId string `protobuf:"bytes,2,opt,name=proposal_id,json=proposalId,proto3,oneof"`
}

type RequestAggrKeysharePacketData_RequestId struct {
	RequestId string `protobuf:"bytes,3,opt,name=request_id,json=requestId,proto3,oneof"`
}

func (*RequestAggrKeysharePacketData_ProposalId) isRequestAggrKeysharePacketData_Id() {}

func (*RequestAggrKeysharePacketData_RequestId) isRequestAggrKeysharePacketData_Id() {}

// RequestAggrKeysharePacketAck defines a struct for the packet acknowledgment
type RequestAggrKeysharePacketAck struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Identity string `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
	Pubkey   string `protobuf:"bytes,2,opt,name=pubkey,proto3" json:"pubkey,omitempty"`
}

func (x *RequestAggrKeysharePacketAck) Reset() {
	*x = RequestAggrKeysharePacketAck{}
	if protoimpl.UnsafeEnabled {
		mi := &file_fairyring_keyshare_packet_proto_msgTypes[3]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *RequestAggrKeysharePacketAck) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RequestAggrKeysharePacketAck) ProtoMessage() {}

// Deprecated: Use RequestAggrKeysharePacketAck.ProtoReflect.Descriptor instead.
func (*RequestAggrKeysharePacketAck) Descriptor() ([]byte, []int) {
	return file_fairyring_keyshare_packet_proto_rawDescGZIP(), []int{3}
}

func (x *RequestAggrKeysharePacketAck) GetIdentity() string {
	if x != nil {
		return x.Identity
	}
	return ""
}

func (x *RequestAggrKeysharePacketAck) GetPubkey() string {
	if x != nil {
		return x.Pubkey
	}
	return ""
}

// GetAggrKeysharePacketData defines a struct for the packet payload
type GetAggrKeysharePacketData struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Identity string `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
}

func (x *GetAggrKeysharePacketData) Reset() {
	*x = GetAggrKeysharePacketData{}
	if protoimpl.UnsafeEnabled {
		mi := &file_fairyring_keyshare_packet_proto_msgTypes[4]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *GetAggrKeysharePacketData) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GetAggrKeysharePacketData) ProtoMessage() {}

// Deprecated: Use GetAggrKeysharePacketData.ProtoReflect.Descriptor instead.
func (*GetAggrKeysharePacketData) Descriptor() ([]byte, []int) {
	return file_fairyring_keyshare_packet_proto_rawDescGZIP(), []int{4}
}

func (x *GetAggrKeysharePacketData) GetIdentity() string {
	if x != nil {
		return x.Identity
	}
	return ""
}

// GetAggrKeysharePacketAck defines a struct for the packet acknowledgment
type GetAggrKeysharePacketAck struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
}

func (x *GetAggrKeysharePacketAck) Reset() {
	*x = GetAggrKeysharePacketAck{}
	if protoimpl.UnsafeEnabled {
		mi := &file_fairyring_keyshare_packet_proto_msgTypes[5]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *GetAggrKeysharePacketAck) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GetAggrKeysharePacketAck) ProtoMessage() {}

// Deprecated: Use GetAggrKeysharePacketAck.ProtoReflect.Descriptor instead.
func (*GetAggrKeysharePacketAck) Descriptor() ([]byte, []int) {
	return file_fairyring_keyshare_packet_proto_rawDescGZIP(), []int{5}
}

// AggrKeyshareDataPacketData defines a struct for the packet payload
type AggrKeyshareDataPacketData struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Identity     string `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
	Pubkey       string `protobuf:"bytes,2,opt,name=pubkey,proto3" json:"pubkey,omitempty"`
	AggrKeyshare string `protobuf:"bytes,3,opt,name=aggr_keyshare,json=aggrKeyshare,proto3" json:"aggr_keyshare,omitempty"`
	AggrHeight   string `protobuf:"bytes,4,opt,name=aggr_height,json=aggrHeight,proto3" json:"aggr_height,omitempty"`
	ProposalId   string `protobuf:"bytes,5,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"` // used for private governance
	RequestId    string `protobuf:"bytes,6,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`    // might be useful to destination chains to sort out the response
	Retries      uint64 `protobuf:"varint,7,opt,name=retries,proto3" json:"retries,omitempty"`
}

func (x *AggrKeyshareDataPacketData) Reset() {
	*x = AggrKeyshareDataPacketData{}
	if protoimpl.UnsafeEnabled {
		mi := &file_fairyring_keyshare_packet_proto_msgTypes[6]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *AggrKeyshareDataPacketData) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AggrKeyshareDataPacketData) ProtoMessage() {}

// Deprecated: Use AggrKeyshareDataPacketData.ProtoReflect.Descriptor instead.
func (*AggrKeyshareDataPacketData) Descriptor() ([]byte, []int) {
	return file_fairyring_keyshare_packet_proto_rawDescGZIP(), []int{6}
}

func (x *AggrKeyshareDataPacketData) GetIdentity() string {
	if x != nil {
		return x.Identity
	}
	return ""
}

func (x *AggrKeyshareDataPacketData) GetPubkey() string {
	if x != nil {
		return x.Pubkey
	}
	return ""
}

func (x *AggrKeyshareDataPacketData) GetAggrKeyshare() string {
	if x != nil {
		return x.AggrKeyshare
	}
	return ""
}

func (x *AggrKeyshareDataPacketData) GetAggrHeight() string {
	if x != nil {
		return x.AggrHeight
	}
	return ""
}

func (x *AggrKeyshareDataPacketData) GetProposalId() string {
	if x != nil {
		return x.ProposalId
	}
	return ""
}

func (x *AggrKeyshareDataPacketData) GetRequestId() string {
	if x != nil {
		return x.RequestId
	}
	return ""
}

func (x *AggrKeyshareDataPacketData) GetRetries() uint64 {
	if x != nil {
		return x.Retries
	}
	return 0
}

// AggrKeyshareDataPacketAck defines a struct for the packet acknowledgment
type AggrKeyshareDataPacketAck struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
}

func (x *AggrKeyshareDataPacketAck) Reset() {
	*x = AggrKeyshareDataPacketAck{}
	if protoimpl.UnsafeEnabled {
		mi := &file_fairyring_keyshare_packet_proto_msgTypes[7]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *AggrKeyshareDataPacketAck) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AggrKeyshareDataPacketAck) ProtoMessage() {}

// Deprecated: Use AggrKeyshareDataPacketAck.ProtoReflect.Descriptor instead.
func (*AggrKeyshareDataPacketAck) Descriptor() ([]byte, []int) {
	return file_fairyring_keyshare_packet_proto_rawDescGZIP(), []int{7}
}

// CurrentKeysPacketData defines a struct for the packet payload
type CurrentKeysPacketData struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields
}

func (x *CurrentKeysPacketData) Reset() {
	*x = CurrentKeysPacketData{}
	if protoimpl.UnsafeEnabled {
		mi := &file_fairyring_keyshare_packet_proto_msgTypes[8]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *CurrentKeysPacketData) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*CurrentKeysPacketData) ProtoMessage() {}

// Deprecated: Use CurrentKeysPacketData.ProtoReflect.Descriptor instead.
func (*CurrentKeysPacketData) Descriptor() ([]byte, []int) {
	return file_fairyring_keyshare_packet_proto_rawDescGZIP(), []int{8}
}

// CurrentKeysPacketAck defines a struct for the packet acknowledgment
type CurrentKeysPacketAck struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	ActiveKey *common.ActivePublicKey `protobuf:"bytes,1,opt,name=activeKey,proto3" json:"activeKey,omitempty"`
	QueuedKey *common.QueuedPublicKey `protobuf:"bytes,2,opt,name=queuedKey,proto3" json:"queuedKey,omitempty"`
}

func (x *CurrentKeysPacketAck) Reset() {
	*x = CurrentKeysPacketAck{}
	if protoimpl.UnsafeEnabled {
		mi := &file_fairyring_keyshare_packet_proto_msgTypes[9]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *CurrentKeysPacketAck) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*CurrentKeysPacketAck) ProtoMessage() {}

// Deprecated: Use CurrentKeysPacketAck.ProtoReflect.Descriptor instead.
func (*CurrentKeysPacketAck) Descriptor() ([]byte, []int) {
	return file_fairyring_keyshare_packet_proto_rawDescGZIP(), []int{9}
}

func (x *CurrentKeysPacketAck) GetActiveKey() *common.ActivePublicKey {
	if x != nil {
		return x.ActiveKey
	}
	return nil
}

func (x *CurrentKeysPacketAck) GetQueuedKey() *common.QueuedPublicKey {
	if x != nil {
		return x.QueuedKey
	}
	return nil
}

var File_fairyring_keyshare_packet_proto protoreflect.FileDescriptor

var file_fairyring_keyshare_packet_proto_rawDesc = []byte{
	0x0a, 0x1f, 0x66, 0x61, 0x69, 0x72, 0x79, 0x72, 0x69, 0x6e, 0x67, 0x2f, 0x6b, 0x65, 0x79, 0x73,
	0x68, 0x61, 0x72, 0x65, 0x2f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74,
	0x6f, 0x12, 0x12, 0x66, 0x61, 0x69, 0x72, 0x79, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x6b, 0x65, 0x79,
	0x73, 0x68, 0x61, 0x72, 0x65, 0x1a, 0x23, 0x66, 0x61, 0x69, 0x72, 0x79, 0x72, 0x69, 0x6e, 0x67,
	0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x5f, 0x74,
	0x79, 0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xf3, 0x03, 0x0a, 0x12, 0x4b,
	0x65, 0x79, 0x73, 0x68, 0x61, 0x72, 0x65, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x44, 0x61, 0x74,
	0x61, 0x12, 0x34, 0x0a, 0x06, 0x6e, 0x6f, 0x44, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28,
	0x0b, 0x32, 0x1a, 0x2e, 0x66, 0x61, 0x69, 0x72, 0x79, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x6b, 0x65,
	0x79, 0x73, 0x68, 0x61, 0x72, 0x65, 0x2e, 0x4e, 0x6f, 0x44, 0x61, 0x74, 0x61, 0x48, 0x00, 0x52,
	0x06, 0x6e, 0x6f, 0x44, 0x61, 0x74, 0x61, 0x12, 0x71, 0x0a, 0x19, 0x72, 0x65, 0x71, 0x75, 0x65,
	0x73, 0x74, 0x41, 0x67, 0x67, 0x72, 0x4b, 0x65, 0x79, 0x73, 0x68, 0x61, 0x72, 0x65, 0x50, 0x61,
	0x63, 0x6b, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x66, 0x61, 0x69,
	0x72, 0x79, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x68, 0x61, 0x72, 0x65, 0x2e,
	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x41, 0x67, 0x67, 0x72, 0x4b, 0x65, 0x79, 0x73, 0x68,
	0x61, 0x72, 0x65, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x00, 0x52,
	0x19, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x41, 0x67, 0x67, 0x72, 0x4b, 0x65, 0x79, 0x73,
	0x68, 0x61, 0x72, 0x65, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x12, 0x65, 0x0a, 0x15, 0x67, 0x65,
	0x74, 0x41, 0x67, 0x67, 0x72, 0x4b, 0x65, 0x79, 0x73, 0x68, 0x61, 0x72, 0x65, 0x50, 0x61, 0x63,
	0x6b, 0x65, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x66, 0x61, 0x69, 0x72,
	0x79, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x68, 0x61, 0x72, 0x65, 0x2e, 0x47,
	0x65, 0x74, 0x41, 0x67, 0x67, 0x72, 0x4b, 0x65, 0x79, 0x73, 0x68, 0x61, 0x72, 0x65, 0x50, 0x61,
	0x63, 0x6b, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x00, 0x52, 0x15, 0x67, 0x65, 0x74, 0x41,
	0x67, 0x67, 0x72, 0x4b, 0x65, 0x79, 0x73, 0x68, 0x61, 0x72, 0x65, 0x50, 0x61, 0x63, 0x6b, 0x65,
	0x74, 0x12, 0x68, 0x0a, 0x16, 0x61, 0x67, 0x67, 0x72, 0x4b, 0x65, 0x79, 0x73, 0x68, 0x61, 0x72,
	0x65, 0x44, 0x61, 0x74, 0x61, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28,
	0x0b, 0x32, 0x2e, 0x2e, 0x66, 0x61, 0x69, 0x72, 0x79, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x6b, 0x65,
	0x79, 0x73, 0x68, 0x61, 0x72, 0x65, 0x2e, 0x41, 0x67, 0x67, 0x72, 0x4b, 0x65, 0x79, 0x73, 0x68,
	0x61, 0x72, 0x65, 0x44, 0x61, 0x74, 0x61, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x44, 0x61, 0x74,
	0x61, 0x48, 0x00, 0x52, 0x16, 0x61, 0x67, 0x67, 0x72, 0x4b, 0x65, 0x79, 0x73, 0x68, 0x61, 0x72,
	0x65, 0x44, 0x61, 0x74, 0x61, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x12, 0x59, 0x0a, 0x11, 0x63,
	0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74,
	0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x66, 0x61, 0x69, 0x72, 0x79, 0x72, 0x69,
	0x6e, 0x67, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x68, 0x61, 0x72, 0x65, 0x2e, 0x43, 0x75, 0x72, 0x72,
	0x65, 0x6e, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x44, 0x61, 0x74,
	0x61, 0x48, 0x00, 0x52, 0x11, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x4b, 0x65, 0x79, 0x73,
	0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x42, 0x08, 0x0a, 0x06, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74,
	0x22, 0x08, 0x0a, 0x06, 0x4e, 0x6f, 0x44, 0x61, 0x74, 0x61, 0x22, 0x87, 0x01, 0x0a, 0x1d, 0x52,
	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x41, 0x67, 0x67, 0x72, 0x4b, 0x65, 0x79, 0x73, 0x68, 0x61,
	0x72, 0x65, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x1c, 0x0a, 0x09,
	0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
	0x09, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x72, 0x12, 0x21, 0x0a, 0x0b, 0x70, 0x72,
	0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48,
	0x00, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x49, 0x64, 0x12, 0x1f, 0x0a,
	0x0a, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28,
	0x09, 0x48, 0x00, 0x52, 0x09, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x42, 0x04,
	0x0a, 0x02, 0x69, 0x64, 0x22, 0x52, 0x0a, 0x1c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x41,
	0x67, 0x67, 0x72, 0x4b, 0x65, 0x79, 0x73, 0x68, 0x61, 0x72, 0x65, 0x50, 0x61, 0x63, 0x6b, 0x65,
	0x74, 0x41, 0x63, 0x6b, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79,
	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79,
	0x12, 0x16, 0x0a, 0x06, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
	0x52, 0x06, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x37, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x41,
	0x67, 0x67, 0x72, 0x4b, 0x65, 0x79, 0x73, 0x68, 0x61, 0x72, 0x65, 0x50, 0x61, 0x63, 0x6b, 0x65,
	0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74,
	0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74,
	0x79, 0x22, 0x1a, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x41, 0x67, 0x67, 0x72, 0x4b, 0x65, 0x79, 0x73,
	0x68, 0x61, 0x72, 0x65, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x41, 0x63, 0x6b, 0x22, 0xf0, 0x01,
	0x0a, 0x1a, 0x41, 0x67, 0x67, 0x72, 0x4b, 0x65, 0x79, 0x73, 0x68, 0x61, 0x72, 0x65, 0x44, 0x61,
	0x74, 0x61, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x1a, 0x0a, 0x08,
	0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08,
	0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x75, 0x62, 0x6b,
	0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79,
	0x12, 0x23, 0x0a, 0x0d, 0x61, 0x67, 0x67, 0x72, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x68, 0x61, 0x72,
	0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x61, 0x67, 0x67, 0x72, 0x4b, 0x65, 0x79,
	0x73, 0x68, 0x61, 0x72, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x67, 0x67, 0x72, 0x5f, 0x68, 0x65,
	0x69, 0x67, 0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x67, 0x67, 0x72,
	0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73,
	0x61, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, 0x72, 0x6f,
	0x70, 0x6f, 0x73, 0x61, 0x6c, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x75, 0x65,
	0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x72, 0x65, 0x71,
	0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65,
	0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x73,
	0x22, 0x1b, 0x0a, 0x19, 0x41, 0x67, 0x67, 0x72, 0x4b, 0x65, 0x79, 0x73, 0x68, 0x61, 0x72, 0x65,
	0x44, 0x61, 0x74, 0x61, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x41, 0x63, 0x6b, 0x22, 0x17, 0x0a,
	0x15, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x50, 0x61, 0x63, 0x6b,
	0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x22, 0x98, 0x01, 0x0a, 0x14, 0x43, 0x75, 0x72, 0x72, 0x65,
	0x6e, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x41, 0x63, 0x6b, 0x12,
	0x3f, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x4b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
	0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x61, 0x69, 0x72, 0x79, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x63,
	0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x50, 0x75, 0x62, 0x6c,
	0x69, 0x63, 0x4b, 0x65, 0x79, 0x52, 0x09, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x4b, 0x65, 0x79,
	0x12, 0x3f, 0x0a, 0x09, 0x71, 0x75, 0x65, 0x75, 0x65, 0x64, 0x4b, 0x65, 0x79, 0x18, 0x02, 0x20,
	0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x66, 0x61, 0x69, 0x72, 0x79, 0x72, 0x69, 0x6e, 0x67, 0x2e,
	0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x51, 0x75, 0x65, 0x75, 0x65, 0x64, 0x50, 0x75, 0x62,
	0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x52, 0x09, 0x71, 0x75, 0x65, 0x75, 0x65, 0x64, 0x4b, 0x65,
	0x79, 0x42, 0xb3, 0x01, 0x0a, 0x16, 0x63, 0x6f, 0x6d, 0x2e, 0x66, 0x61, 0x69, 0x72, 0x79, 0x72,
	0x69, 0x6e, 0x67, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x68, 0x61, 0x72, 0x65, 0x42, 0x0b, 0x50, 0x61,
	0x63, 0x6b, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x23, 0x63, 0x6f, 0x73,
	0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x66, 0x61,
	0x69, 0x72, 0x79, 0x72, 0x69, 0x6e, 0x67, 0x2f, 0x6b, 0x65, 0x79, 0x73, 0x68, 0x61, 0x72, 0x65,
	0xa2, 0x02, 0x03, 0x46, 0x4b, 0x58, 0xaa, 0x02, 0x12, 0x46, 0x61, 0x69, 0x72, 0x79, 0x72, 0x69,
	0x6e, 0x67, 0x2e, 0x4b, 0x65, 0x79, 0x73, 0x68, 0x61, 0x72, 0x65, 0xca, 0x02, 0x12, 0x46, 0x61,
	0x69, 0x72, 0x79, 0x72, 0x69, 0x6e, 0x67, 0x5c, 0x4b, 0x65, 0x79, 0x73, 0x68, 0x61, 0x72, 0x65,
	0xe2, 0x02, 0x1e, 0x46, 0x61, 0x69, 0x72, 0x79, 0x72, 0x69, 0x6e, 0x67, 0x5c, 0x4b, 0x65, 0x79,
	0x73, 0x68, 0x61, 0x72, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
	0x61, 0xea, 0x02, 0x13, 0x46, 0x61, 0x69, 0x72, 0x79, 0x72, 0x69, 0x6e, 0x67, 0x3a, 0x3a, 0x4b,
	0x65, 0x79, 0x73, 0x68, 0x61, 0x72, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}

var (
	file_fairyring_keyshare_packet_proto_rawDescOnce sync.Once
	file_fairyring_keyshare_packet_proto_rawDescData = file_fairyring_keyshare_packet_proto_rawDesc
)

func file_fairyring_keyshare_packet_proto_rawDescGZIP() []byte {
	file_fairyring_keyshare_packet_proto_rawDescOnce.Do(func() {
		file_fairyring_keyshare_packet_proto_rawDescData = protoimpl.X.CompressGZIP(file_fairyring_keyshare_packet_proto_rawDescData)
	})
	return file_fairyring_keyshare_packet_proto_rawDescData
}

var file_fairyring_keyshare_packet_proto_msgTypes = make([]protoimpl.MessageInfo, 10)
var file_fairyring_keyshare_packet_proto_goTypes = []interface{}{
	(*KeysharePacketData)(nil),            // 0: fairyring.keyshare.KeysharePacketData
	(*NoData)(nil),                        // 1: fairyring.keyshare.NoData
	(*RequestAggrKeysharePacketData)(nil), // 2: fairyring.keyshare.RequestAggrKeysharePacketData
	(*RequestAggrKeysharePacketAck)(nil),  // 3: fairyring.keyshare.RequestAggrKeysharePacketAck
	(*GetAggrKeysharePacketData)(nil),     // 4: fairyring.keyshare.GetAggrKeysharePacketData
	(*GetAggrKeysharePacketAck)(nil),      // 5: fairyring.keyshare.GetAggrKeysharePacketAck
	(*AggrKeyshareDataPacketData)(nil),    // 6: fairyring.keyshare.AggrKeyshareDataPacketData
	(*AggrKeyshareDataPacketAck)(nil),     // 7: fairyring.keyshare.AggrKeyshareDataPacketAck
	(*CurrentKeysPacketData)(nil),         // 8: fairyring.keyshare.CurrentKeysPacketData
	(*CurrentKeysPacketAck)(nil),          // 9: fairyring.keyshare.CurrentKeysPacketAck
	(*common.ActivePublicKey)(nil),        // 10: fairyring.common.ActivePublicKey
	(*common.QueuedPublicKey)(nil),        // 11: fairyring.common.QueuedPublicKey
}
var file_fairyring_keyshare_packet_proto_depIdxs = []int32{
	1,  // 0: fairyring.keyshare.KeysharePacketData.noData:type_name -> fairyring.keyshare.NoData
	2,  // 1: fairyring.keyshare.KeysharePacketData.requestAggrKeysharePacket:type_name -> fairyring.keyshare.RequestAggrKeysharePacketData
	4,  // 2: fairyring.keyshare.KeysharePacketData.getAggrKeysharePacket:type_name -> fairyring.keyshare.GetAggrKeysharePacketData
	6,  // 3: fairyring.keyshare.KeysharePacketData.aggrKeyshareDataPacket:type_name -> fairyring.keyshare.AggrKeyshareDataPacketData
	8,  // 4: fairyring.keyshare.KeysharePacketData.currentKeysPacket:type_name -> fairyring.keyshare.CurrentKeysPacketData
	10, // 5: fairyring.keyshare.CurrentKeysPacketAck.activeKey:type_name -> fairyring.common.ActivePublicKey
	11, // 6: fairyring.keyshare.CurrentKeysPacketAck.queuedKey:type_name -> fairyring.common.QueuedPublicKey
	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_fairyring_keyshare_packet_proto_init() }
func file_fairyring_keyshare_packet_proto_init() {
	if File_fairyring_keyshare_packet_proto != nil {
		return
	}
	if !protoimpl.UnsafeEnabled {
		file_fairyring_keyshare_packet_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*KeysharePacketData); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_fairyring_keyshare_packet_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*NoData); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_fairyring_keyshare_packet_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*RequestAggrKeysharePacketData); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_fairyring_keyshare_packet_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*RequestAggrKeysharePacketAck); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_fairyring_keyshare_packet_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*GetAggrKeysharePacketData); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_fairyring_keyshare_packet_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*GetAggrKeysharePacketAck); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_fairyring_keyshare_packet_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*AggrKeyshareDataPacketData); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_fairyring_keyshare_packet_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*AggrKeyshareDataPacketAck); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_fairyring_keyshare_packet_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*CurrentKeysPacketData); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_fairyring_keyshare_packet_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*CurrentKeysPacketAck); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
	}
	file_fairyring_keyshare_packet_proto_msgTypes[0].OneofWrappers = []interface{}{
		(*KeysharePacketData_NoData)(nil),
		(*KeysharePacketData_RequestAggrKeysharePacket)(nil),
		(*KeysharePacketData_GetAggrKeysharePacket)(nil),
		(*KeysharePacketData_AggrKeyshareDataPacket)(nil),
		(*KeysharePacketData_CurrentKeysPacket)(nil),
	}
	file_fairyring_keyshare_packet_proto_msgTypes[2].OneofWrappers = []interface{}{
		(*RequestAggrKeysharePacketData_ProposalId)(nil),
		(*RequestAggrKeysharePacketData_RequestId)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: file_fairyring_keyshare_packet_proto_rawDesc,
			NumEnums:      0,
			NumMessages:   10,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_fairyring_keyshare_packet_proto_goTypes,
		DependencyIndexes: file_fairyring_keyshare_packet_proto_depIdxs,
		MessageInfos:      file_fairyring_keyshare_packet_proto_msgTypes,
	}.Build()
	File_fairyring_keyshare_packet_proto = out.File
	file_fairyring_keyshare_packet_proto_rawDesc = nil
	file_fairyring_keyshare_packet_proto_goTypes = nil
	file_fairyring_keyshare_packet_proto_depIdxs = nil
}