// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.10
// 	protoc        v6.32.1
// source: util/kafka/kafka_message/kafka_messages.proto

package kafkamessage

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

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 KafkaTxMetaActionType int32

const (
	KafkaTxMetaActionType_ADD    KafkaTxMetaActionType = 0
	KafkaTxMetaActionType_DELETE KafkaTxMetaActionType = 1
)

// Enum value maps for KafkaTxMetaActionType.
var (
	KafkaTxMetaActionType_name = map[int32]string{
		0: "ADD",
		1: "DELETE",
	}
	KafkaTxMetaActionType_value = map[string]int32{
		"ADD":    0,
		"DELETE": 1,
	}
)

func (x KafkaTxMetaActionType) Enum() *KafkaTxMetaActionType {
	p := new(KafkaTxMetaActionType)
	*p = x
	return p
}

func (x KafkaTxMetaActionType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (KafkaTxMetaActionType) Descriptor() protoreflect.EnumDescriptor {
	return file_util_kafka_kafka_message_kafka_messages_proto_enumTypes[0].Descriptor()
}

func (KafkaTxMetaActionType) Type() protoreflect.EnumType {
	return &file_util_kafka_kafka_message_kafka_messages_proto_enumTypes[0]
}

func (x KafkaTxMetaActionType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use KafkaTxMetaActionType.Descriptor instead.
func (KafkaTxMetaActionType) EnumDescriptor() ([]byte, []int) {
	return file_util_kafka_kafka_message_kafka_messages_proto_rawDescGZIP(), []int{0}
}

type InvType int32

const (
	InvType_Error         InvType = 0
	InvType_Tx            InvType = 1
	InvType_Block         InvType = 2
	InvType_FilteredBlock InvType = 3
)

// Enum value maps for InvType.
var (
	InvType_name = map[int32]string{
		0: "Error",
		1: "Tx",
		2: "Block",
		3: "FilteredBlock",
	}
	InvType_value = map[string]int32{
		"Error":         0,
		"Tx":            1,
		"Block":         2,
		"FilteredBlock": 3,
	}
)

func (x InvType) Enum() *InvType {
	p := new(InvType)
	*p = x
	return p
}

func (x InvType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (InvType) Descriptor() protoreflect.EnumDescriptor {
	return file_util_kafka_kafka_message_kafka_messages_proto_enumTypes[1].Descriptor()
}

func (InvType) Type() protoreflect.EnumType {
	return &file_util_kafka_kafka_message_kafka_messages_proto_enumTypes[1]
}

func (x InvType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use InvType.Descriptor instead.
func (InvType) EnumDescriptor() ([]byte, []int) {
	return file_util_kafka_kafka_message_kafka_messages_proto_rawDescGZIP(), []int{1}
}

type KafkaBlockTopicMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Hash          string                 `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	URL           string                 `protobuf:"bytes,2,opt,name=URL,proto3" json:"URL,omitempty"`
	PeerId        string                 `protobuf:"bytes,3,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"` // P2P peer identifier for peerMetrics tracking
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KafkaBlockTopicMessage) Reset() {
	*x = KafkaBlockTopicMessage{}
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*KafkaBlockTopicMessage) ProtoMessage() {}

func (x *KafkaBlockTopicMessage) ProtoReflect() protoreflect.Message {
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

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

func (x *KafkaBlockTopicMessage) GetHash() string {
	if x != nil {
		return x.Hash
	}
	return ""
}

func (x *KafkaBlockTopicMessage) GetURL() string {
	if x != nil {
		return x.URL
	}
	return ""
}

func (x *KafkaBlockTopicMessage) GetPeerId() string {
	if x != nil {
		return x.PeerId
	}
	return ""
}

type KafkaInvalidBlockTopicMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	BlockHash     string                 `protobuf:"bytes,1,opt,name=blockHash,proto3" json:"blockHash,omitempty"`
	Reason        string                 `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KafkaInvalidBlockTopicMessage) Reset() {
	*x = KafkaInvalidBlockTopicMessage{}
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*KafkaInvalidBlockTopicMessage) ProtoMessage() {}

func (x *KafkaInvalidBlockTopicMessage) ProtoReflect() protoreflect.Message {
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

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

func (x *KafkaInvalidBlockTopicMessage) GetBlockHash() string {
	if x != nil {
		return x.BlockHash
	}
	return ""
}

func (x *KafkaInvalidBlockTopicMessage) GetReason() string {
	if x != nil {
		return x.Reason
	}
	return ""
}

type KafkaInvalidSubtreeTopicMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	SubtreeHash   string                 `protobuf:"bytes,1,opt,name=subtreeHash,proto3" json:"subtreeHash,omitempty"`
	PeerUrl       string                 `protobuf:"bytes,2,opt,name=peerUrl,proto3" json:"peerUrl,omitempty"`
	Reason        string                 `protobuf:"bytes,3,opt,name=reason,proto3" json:"reason,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KafkaInvalidSubtreeTopicMessage) Reset() {
	*x = KafkaInvalidSubtreeTopicMessage{}
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*KafkaInvalidSubtreeTopicMessage) ProtoMessage() {}

func (x *KafkaInvalidSubtreeTopicMessage) ProtoReflect() protoreflect.Message {
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

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

func (x *KafkaInvalidSubtreeTopicMessage) GetSubtreeHash() string {
	if x != nil {
		return x.SubtreeHash
	}
	return ""
}

func (x *KafkaInvalidSubtreeTopicMessage) GetPeerUrl() string {
	if x != nil {
		return x.PeerUrl
	}
	return ""
}

func (x *KafkaInvalidSubtreeTopicMessage) GetReason() string {
	if x != nil {
		return x.Reason
	}
	return ""
}

type KafkaSubtreeTopicMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Hash          string                 `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	URL           string                 `protobuf:"bytes,2,opt,name=URL,proto3" json:"URL,omitempty"`
	PeerId        string                 `protobuf:"bytes,3,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"` // Originator peer ID
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KafkaSubtreeTopicMessage) Reset() {
	*x = KafkaSubtreeTopicMessage{}
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*KafkaSubtreeTopicMessage) ProtoMessage() {}

func (x *KafkaSubtreeTopicMessage) ProtoReflect() protoreflect.Message {
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

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

func (x *KafkaSubtreeTopicMessage) GetHash() string {
	if x != nil {
		return x.Hash
	}
	return ""
}

func (x *KafkaSubtreeTopicMessage) GetURL() string {
	if x != nil {
		return x.URL
	}
	return ""
}

func (x *KafkaSubtreeTopicMessage) GetPeerId() string {
	if x != nil {
		return x.PeerId
	}
	return ""
}

type KafkaTxValidationTopicMessage struct {
	state         protoimpl.MessageState    `protogen:"open.v1"`
	Tx            []byte                    `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
	Height        uint32                    `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
	Options       *KafkaTxValidationOptions `protobuf:"bytes,3,opt,name=options,proto3" json:"options,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KafkaTxValidationTopicMessage) Reset() {
	*x = KafkaTxValidationTopicMessage{}
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*KafkaTxValidationTopicMessage) ProtoMessage() {}

func (x *KafkaTxValidationTopicMessage) ProtoReflect() protoreflect.Message {
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

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

func (x *KafkaTxValidationTopicMessage) GetTx() []byte {
	if x != nil {
		return x.Tx
	}
	return nil
}

func (x *KafkaTxValidationTopicMessage) GetHeight() uint32 {
	if x != nil {
		return x.Height
	}
	return 0
}

func (x *KafkaTxValidationTopicMessage) GetOptions() *KafkaTxValidationOptions {
	if x != nil {
		return x.Options
	}
	return nil
}

type KafkaTxValidationOptions struct {
	state                protoimpl.MessageState `protogen:"open.v1"`
	SkipUtxoCreation     bool                   `protobuf:"varint,1,opt,name=skipUtxoCreation,proto3" json:"skipUtxoCreation,omitempty"`
	AddTXToBlockAssembly bool                   `protobuf:"varint,2,opt,name=addTXToBlockAssembly,proto3" json:"addTXToBlockAssembly,omitempty"`
	SkipPolicyChecks     bool                   `protobuf:"varint,3,opt,name=skipPolicyChecks,proto3" json:"skipPolicyChecks,omitempty"`
	CreateConflicting    bool                   `protobuf:"varint,4,opt,name=createConflicting,proto3" json:"createConflicting,omitempty"`
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

func (x *KafkaTxValidationOptions) Reset() {
	*x = KafkaTxValidationOptions{}
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*KafkaTxValidationOptions) ProtoMessage() {}

func (x *KafkaTxValidationOptions) ProtoReflect() protoreflect.Message {
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

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

func (x *KafkaTxValidationOptions) GetSkipUtxoCreation() bool {
	if x != nil {
		return x.SkipUtxoCreation
	}
	return false
}

func (x *KafkaTxValidationOptions) GetAddTXToBlockAssembly() bool {
	if x != nil {
		return x.AddTXToBlockAssembly
	}
	return false
}

func (x *KafkaTxValidationOptions) GetSkipPolicyChecks() bool {
	if x != nil {
		return x.SkipPolicyChecks
	}
	return false
}

func (x *KafkaTxValidationOptions) GetCreateConflicting() bool {
	if x != nil {
		return x.CreateConflicting
	}
	return false
}

type KafkaRejectedTxTopicMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	TxHash        string                 `protobuf:"bytes,1,opt,name=txHash,proto3" json:"txHash,omitempty"`
	Reason        string                 `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
	PeerId        string                 `protobuf:"bytes,3,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"` // Empty = internal rejection, non-empty = external peer
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KafkaRejectedTxTopicMessage) Reset() {
	*x = KafkaRejectedTxTopicMessage{}
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*KafkaRejectedTxTopicMessage) ProtoMessage() {}

func (x *KafkaRejectedTxTopicMessage) ProtoReflect() protoreflect.Message {
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

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

func (x *KafkaRejectedTxTopicMessage) GetTxHash() string {
	if x != nil {
		return x.TxHash
	}
	return ""
}

func (x *KafkaRejectedTxTopicMessage) GetReason() string {
	if x != nil {
		return x.Reason
	}
	return ""
}

func (x *KafkaRejectedTxTopicMessage) GetPeerId() string {
	if x != nil {
		return x.PeerId
	}
	return ""
}

type KafkaTxMetaTopicMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	TxHash        string                 `protobuf:"bytes,1,opt,name=txHash,proto3" json:"txHash,omitempty"`
	Action        KafkaTxMetaActionType  `protobuf:"varint,2,opt,name=action,proto3,enum=kafkamessage.KafkaTxMetaActionType" json:"action,omitempty"`
	Content       []byte                 `protobuf:"bytes,3,opt,name=content,proto3" json:"content,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KafkaTxMetaTopicMessage) Reset() {
	*x = KafkaTxMetaTopicMessage{}
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*KafkaTxMetaTopicMessage) ProtoMessage() {}

func (x *KafkaTxMetaTopicMessage) ProtoReflect() protoreflect.Message {
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

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

func (x *KafkaTxMetaTopicMessage) GetTxHash() string {
	if x != nil {
		return x.TxHash
	}
	return ""
}

func (x *KafkaTxMetaTopicMessage) GetAction() KafkaTxMetaActionType {
	if x != nil {
		return x.Action
	}
	return KafkaTxMetaActionType_ADD
}

func (x *KafkaTxMetaTopicMessage) GetContent() []byte {
	if x != nil {
		return x.Content
	}
	return nil
}

type KafkaInvTopicMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	PeerAddress   string                 `protobuf:"bytes,1,opt,name=peerAddress,proto3" json:"peerAddress,omitempty"`
	Inv           []*Inv                 `protobuf:"bytes,2,rep,name=inv,proto3" json:"inv,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KafkaInvTopicMessage) Reset() {
	*x = KafkaInvTopicMessage{}
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*KafkaInvTopicMessage) ProtoMessage() {}

func (x *KafkaInvTopicMessage) ProtoReflect() protoreflect.Message {
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

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

func (x *KafkaInvTopicMessage) GetPeerAddress() string {
	if x != nil {
		return x.PeerAddress
	}
	return ""
}

func (x *KafkaInvTopicMessage) GetInv() []*Inv {
	if x != nil {
		return x.Inv
	}
	return nil
}

type Inv struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Type          InvType                `protobuf:"varint,1,opt,name=type,proto3,enum=kafkamessage.InvType" json:"type,omitempty"`
	Hash          string                 `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Inv) Reset() {
	*x = Inv{}
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Inv) ProtoMessage() {}

func (x *Inv) ProtoReflect() protoreflect.Message {
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

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

func (x *Inv) GetType() InvType {
	if x != nil {
		return x.Type
	}
	return InvType_Error
}

func (x *Inv) GetHash() string {
	if x != nil {
		return x.Hash
	}
	return ""
}

type KafkaBlocksFinalTopicMessage struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	Header           []byte                 `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`                                              // Block header bytes
	TransactionCount uint64                 `protobuf:"varint,2,opt,name=transaction_count,json=transactionCount,proto3" json:"transaction_count,omitempty"` // Number of transactions in block
	SizeInBytes      uint64                 `protobuf:"varint,3,opt,name=size_in_bytes,json=sizeInBytes,proto3" json:"size_in_bytes,omitempty"`              // Size of block in bytes
	SubtreeHashes    [][]byte               `protobuf:"bytes,4,rep,name=subtree_hashes,json=subtreeHashes,proto3" json:"subtree_hashes,omitempty"`           // Merkle tree subtree hashes
	CoinbaseTx       []byte                 `protobuf:"bytes,5,opt,name=coinbase_tx,json=coinbaseTx,proto3" json:"coinbase_tx,omitempty"`                    // Coinbase transaction bytes
	Height           uint32                 `protobuf:"varint,6,opt,name=height,proto3" json:"height,omitempty"`                                             // Block height
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *KafkaBlocksFinalTopicMessage) Reset() {
	*x = KafkaBlocksFinalTopicMessage{}
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*KafkaBlocksFinalTopicMessage) ProtoMessage() {}

func (x *KafkaBlocksFinalTopicMessage) ProtoReflect() protoreflect.Message {
	mi := &file_util_kafka_kafka_message_kafka_messages_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KafkaBlocksFinalTopicMessage.ProtoReflect.Descriptor instead.
func (*KafkaBlocksFinalTopicMessage) Descriptor() ([]byte, []int) {
	return file_util_kafka_kafka_message_kafka_messages_proto_rawDescGZIP(), []int{10}
}

func (x *KafkaBlocksFinalTopicMessage) GetHeader() []byte {
	if x != nil {
		return x.Header
	}
	return nil
}

func (x *KafkaBlocksFinalTopicMessage) GetTransactionCount() uint64 {
	if x != nil {
		return x.TransactionCount
	}
	return 0
}

func (x *KafkaBlocksFinalTopicMessage) GetSizeInBytes() uint64 {
	if x != nil {
		return x.SizeInBytes
	}
	return 0
}

func (x *KafkaBlocksFinalTopicMessage) GetSubtreeHashes() [][]byte {
	if x != nil {
		return x.SubtreeHashes
	}
	return nil
}

func (x *KafkaBlocksFinalTopicMessage) GetCoinbaseTx() []byte {
	if x != nil {
		return x.CoinbaseTx
	}
	return nil
}

func (x *KafkaBlocksFinalTopicMessage) GetHeight() uint32 {
	if x != nil {
		return x.Height
	}
	return 0
}

var File_util_kafka_kafka_message_kafka_messages_proto protoreflect.FileDescriptor

const file_util_kafka_kafka_message_kafka_messages_proto_rawDesc = "" +
	"\n" +
	"-util/kafka/kafka_message/kafka_messages.proto\x12\fkafkamessage\"W\n" +
	"\x16KafkaBlockTopicMessage\x12\x12\n" +
	"\x04hash\x18\x01 \x01(\tR\x04hash\x12\x10\n" +
	"\x03URL\x18\x02 \x01(\tR\x03URL\x12\x17\n" +
	"\apeer_id\x18\x03 \x01(\tR\x06peerId\"U\n" +
	"\x1dKafkaInvalidBlockTopicMessage\x12\x1c\n" +
	"\tblockHash\x18\x01 \x01(\tR\tblockHash\x12\x16\n" +
	"\x06reason\x18\x02 \x01(\tR\x06reason\"u\n" +
	"\x1fKafkaInvalidSubtreeTopicMessage\x12 \n" +
	"\vsubtreeHash\x18\x01 \x01(\tR\vsubtreeHash\x12\x18\n" +
	"\apeerUrl\x18\x02 \x01(\tR\apeerUrl\x12\x16\n" +
	"\x06reason\x18\x03 \x01(\tR\x06reason\"Y\n" +
	"\x18KafkaSubtreeTopicMessage\x12\x12\n" +
	"\x04hash\x18\x01 \x01(\tR\x04hash\x12\x10\n" +
	"\x03URL\x18\x02 \x01(\tR\x03URL\x12\x17\n" +
	"\apeer_id\x18\x03 \x01(\tR\x06peerId\"\x89\x01\n" +
	"\x1dKafkaTxValidationTopicMessage\x12\x0e\n" +
	"\x02tx\x18\x01 \x01(\fR\x02tx\x12\x16\n" +
	"\x06height\x18\x02 \x01(\rR\x06height\x12@\n" +
	"\aoptions\x18\x03 \x01(\v2&.kafkamessage.KafkaTxValidationOptionsR\aoptions\"\xd4\x01\n" +
	"\x18KafkaTxValidationOptions\x12*\n" +
	"\x10skipUtxoCreation\x18\x01 \x01(\bR\x10skipUtxoCreation\x122\n" +
	"\x14addTXToBlockAssembly\x18\x02 \x01(\bR\x14addTXToBlockAssembly\x12*\n" +
	"\x10skipPolicyChecks\x18\x03 \x01(\bR\x10skipPolicyChecks\x12,\n" +
	"\x11createConflicting\x18\x04 \x01(\bR\x11createConflicting\"f\n" +
	"\x1bKafkaRejectedTxTopicMessage\x12\x16\n" +
	"\x06txHash\x18\x01 \x01(\tR\x06txHash\x12\x16\n" +
	"\x06reason\x18\x02 \x01(\tR\x06reason\x12\x17\n" +
	"\apeer_id\x18\x03 \x01(\tR\x06peerId\"\x88\x01\n" +
	"\x17KafkaTxMetaTopicMessage\x12\x16\n" +
	"\x06txHash\x18\x01 \x01(\tR\x06txHash\x12;\n" +
	"\x06action\x18\x02 \x01(\x0e2#.kafkamessage.KafkaTxMetaActionTypeR\x06action\x12\x18\n" +
	"\acontent\x18\x03 \x01(\fR\acontent\"]\n" +
	"\x14KafkaInvTopicMessage\x12 \n" +
	"\vpeerAddress\x18\x01 \x01(\tR\vpeerAddress\x12#\n" +
	"\x03inv\x18\x02 \x03(\v2\x11.kafkamessage.InvR\x03inv\"D\n" +
	"\x03Inv\x12)\n" +
	"\x04type\x18\x01 \x01(\x0e2\x15.kafkamessage.InvTypeR\x04type\x12\x12\n" +
	"\x04hash\x18\x02 \x01(\tR\x04hash\"\xe7\x01\n" +
	"\x1cKafkaBlocksFinalTopicMessage\x12\x16\n" +
	"\x06header\x18\x01 \x01(\fR\x06header\x12+\n" +
	"\x11transaction_count\x18\x02 \x01(\x04R\x10transactionCount\x12\"\n" +
	"\rsize_in_bytes\x18\x03 \x01(\x04R\vsizeInBytes\x12%\n" +
	"\x0esubtree_hashes\x18\x04 \x03(\fR\rsubtreeHashes\x12\x1f\n" +
	"\vcoinbase_tx\x18\x05 \x01(\fR\n" +
	"coinbaseTx\x12\x16\n" +
	"\x06height\x18\x06 \x01(\rR\x06height*,\n" +
	"\x15KafkaTxMetaActionType\x12\a\n" +
	"\x03ADD\x10\x00\x12\n" +
	"\n" +
	"\x06DELETE\x10\x01*:\n" +
	"\aInvType\x12\t\n" +
	"\x05Error\x10\x00\x12\x06\n" +
	"\x02Tx\x10\x01\x12\t\n" +
	"\x05Block\x10\x02\x12\x11\n" +
	"\rFilteredBlock\x10\x03B\x11Z\x0f./;kafkamessageb\x06proto3"

var (
	file_util_kafka_kafka_message_kafka_messages_proto_rawDescOnce sync.Once
	file_util_kafka_kafka_message_kafka_messages_proto_rawDescData []byte
)

func file_util_kafka_kafka_message_kafka_messages_proto_rawDescGZIP() []byte {
	file_util_kafka_kafka_message_kafka_messages_proto_rawDescOnce.Do(func() {
		file_util_kafka_kafka_message_kafka_messages_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_util_kafka_kafka_message_kafka_messages_proto_rawDesc), len(file_util_kafka_kafka_message_kafka_messages_proto_rawDesc)))
	})
	return file_util_kafka_kafka_message_kafka_messages_proto_rawDescData
}

var file_util_kafka_kafka_message_kafka_messages_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_util_kafka_kafka_message_kafka_messages_proto_msgTypes = make([]protoimpl.MessageInfo, 11)
var file_util_kafka_kafka_message_kafka_messages_proto_goTypes = []any{
	(KafkaTxMetaActionType)(0),              // 0: kafkamessage.KafkaTxMetaActionType
	(InvType)(0),                            // 1: kafkamessage.InvType
	(*KafkaBlockTopicMessage)(nil),          // 2: kafkamessage.KafkaBlockTopicMessage
	(*KafkaInvalidBlockTopicMessage)(nil),   // 3: kafkamessage.KafkaInvalidBlockTopicMessage
	(*KafkaInvalidSubtreeTopicMessage)(nil), // 4: kafkamessage.KafkaInvalidSubtreeTopicMessage
	(*KafkaSubtreeTopicMessage)(nil),        // 5: kafkamessage.KafkaSubtreeTopicMessage
	(*KafkaTxValidationTopicMessage)(nil),   // 6: kafkamessage.KafkaTxValidationTopicMessage
	(*KafkaTxValidationOptions)(nil),        // 7: kafkamessage.KafkaTxValidationOptions
	(*KafkaRejectedTxTopicMessage)(nil),     // 8: kafkamessage.KafkaRejectedTxTopicMessage
	(*KafkaTxMetaTopicMessage)(nil),         // 9: kafkamessage.KafkaTxMetaTopicMessage
	(*KafkaInvTopicMessage)(nil),            // 10: kafkamessage.KafkaInvTopicMessage
	(*Inv)(nil),                             // 11: kafkamessage.Inv
	(*KafkaBlocksFinalTopicMessage)(nil),    // 12: kafkamessage.KafkaBlocksFinalTopicMessage
}
var file_util_kafka_kafka_message_kafka_messages_proto_depIdxs = []int32{
	7,  // 0: kafkamessage.KafkaTxValidationTopicMessage.options:type_name -> kafkamessage.KafkaTxValidationOptions
	0,  // 1: kafkamessage.KafkaTxMetaTopicMessage.action:type_name -> kafkamessage.KafkaTxMetaActionType
	11, // 2: kafkamessage.KafkaInvTopicMessage.inv:type_name -> kafkamessage.Inv
	1,  // 3: kafkamessage.Inv.type:type_name -> kafkamessage.InvType
	4,  // [4:4] is the sub-list for method output_type
	4,  // [4:4] is the sub-list for method input_type
	4,  // [4:4] is the sub-list for extension type_name
	4,  // [4:4] is the sub-list for extension extendee
	0,  // [0:4] is the sub-list for field type_name
}

func init() { file_util_kafka_kafka_message_kafka_messages_proto_init() }
func file_util_kafka_kafka_message_kafka_messages_proto_init() {
	if File_util_kafka_kafka_message_kafka_messages_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_util_kafka_kafka_message_kafka_messages_proto_rawDesc), len(file_util_kafka_kafka_message_kafka_messages_proto_rawDesc)),
			NumEnums:      2,
			NumMessages:   11,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_util_kafka_kafka_message_kafka_messages_proto_goTypes,
		DependencyIndexes: file_util_kafka_kafka_message_kafka_messages_proto_depIdxs,
		EnumInfos:         file_util_kafka_kafka_message_kafka_messages_proto_enumTypes,
		MessageInfos:      file_util_kafka_kafka_message_kafka_messages_proto_msgTypes,
	}.Build()
	File_util_kafka_kafka_message_kafka_messages_proto = out.File
	file_util_kafka_kafka_message_kafka_messages_proto_goTypes = nil
	file_util_kafka_kafka_message_kafka_messages_proto_depIdxs = nil
}
