// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        v5.29.3
// source: gossip.proto

package gossip

import (
	_ "github.com/lightsparkdev/spark/proto/common"
	spark "github.com/lightsparkdev/spark/proto/spark"
	spark_internal "github.com/lightsparkdev/spark/proto/spark_internal"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	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 GossipMessage struct {
	state     protoimpl.MessageState `protogen:"open.v1"`
	MessageId string                 `protobuf:"bytes,1,opt,name=message_id,json=messageId,proto3" json:"message_id,omitempty"`
	// Types that are valid to be assigned to Message:
	//
	//	*GossipMessage_CancelTransfer
	//	*GossipMessage_SettleSenderKeyTweak
	//	*GossipMessage_RollbackTransfer
	//	*GossipMessage_MarkTreesExited
	//	*GossipMessage_FinalizeTreeCreation
	//	*GossipMessage_FinalizeTransfer
	//	*GossipMessage_FinalizeRefreshTimelock
	//	*GossipMessage_FinalizeExtendLeaf
	//	*GossipMessage_RollbackUtxoSwap
	//	*GossipMessage_DepositCleanup
	//	*GossipMessage_Preimage
	//	*GossipMessage_FinalizeRefundTimelock
	//	*GossipMessage_FinalizeNodeTimelock
	Message       isGossipMessage_Message `protobuf_oneof:"message"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GossipMessage) ProtoMessage() {}

func (x *GossipMessage) ProtoReflect() protoreflect.Message {
	mi := &file_gossip_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 GossipMessage.ProtoReflect.Descriptor instead.
func (*GossipMessage) Descriptor() ([]byte, []int) {
	return file_gossip_proto_rawDescGZIP(), []int{0}
}

func (x *GossipMessage) GetMessageId() string {
	if x != nil {
		return x.MessageId
	}
	return ""
}

func (x *GossipMessage) GetMessage() isGossipMessage_Message {
	if x != nil {
		return x.Message
	}
	return nil
}

func (x *GossipMessage) GetCancelTransfer() *GossipMessageCancelTransfer {
	if x != nil {
		if x, ok := x.Message.(*GossipMessage_CancelTransfer); ok {
			return x.CancelTransfer
		}
	}
	return nil
}

func (x *GossipMessage) GetSettleSenderKeyTweak() *GossipMessageSettleSenderKeyTweak {
	if x != nil {
		if x, ok := x.Message.(*GossipMessage_SettleSenderKeyTweak); ok {
			return x.SettleSenderKeyTweak
		}
	}
	return nil
}

func (x *GossipMessage) GetRollbackTransfer() *GossipMessageRollbackTransfer {
	if x != nil {
		if x, ok := x.Message.(*GossipMessage_RollbackTransfer); ok {
			return x.RollbackTransfer
		}
	}
	return nil
}

func (x *GossipMessage) GetMarkTreesExited() *GossipMessageMarkTreesExited {
	if x != nil {
		if x, ok := x.Message.(*GossipMessage_MarkTreesExited); ok {
			return x.MarkTreesExited
		}
	}
	return nil
}

func (x *GossipMessage) GetFinalizeTreeCreation() *GossipMessageFinalizeTreeCreation {
	if x != nil {
		if x, ok := x.Message.(*GossipMessage_FinalizeTreeCreation); ok {
			return x.FinalizeTreeCreation
		}
	}
	return nil
}

func (x *GossipMessage) GetFinalizeTransfer() *GossipMessageFinalizeTransfer {
	if x != nil {
		if x, ok := x.Message.(*GossipMessage_FinalizeTransfer); ok {
			return x.FinalizeTransfer
		}
	}
	return nil
}

func (x *GossipMessage) GetFinalizeRefreshTimelock() *GossipMessageFinalizeRefreshTimelock {
	if x != nil {
		if x, ok := x.Message.(*GossipMessage_FinalizeRefreshTimelock); ok {
			return x.FinalizeRefreshTimelock
		}
	}
	return nil
}

func (x *GossipMessage) GetFinalizeExtendLeaf() *GossipMessageFinalizeExtendLeaf {
	if x != nil {
		if x, ok := x.Message.(*GossipMessage_FinalizeExtendLeaf); ok {
			return x.FinalizeExtendLeaf
		}
	}
	return nil
}

func (x *GossipMessage) GetRollbackUtxoSwap() *GossipMessageRollbackUtxoSwap {
	if x != nil {
		if x, ok := x.Message.(*GossipMessage_RollbackUtxoSwap); ok {
			return x.RollbackUtxoSwap
		}
	}
	return nil
}

func (x *GossipMessage) GetDepositCleanup() *GossipMessageDepositCleanup {
	if x != nil {
		if x, ok := x.Message.(*GossipMessage_DepositCleanup); ok {
			return x.DepositCleanup
		}
	}
	return nil
}

func (x *GossipMessage) GetPreimage() *GossipMessagePreimage {
	if x != nil {
		if x, ok := x.Message.(*GossipMessage_Preimage); ok {
			return x.Preimage
		}
	}
	return nil
}

func (x *GossipMessage) GetFinalizeRefundTimelock() *GossipMessageFinalizeRenewRefundTimelock {
	if x != nil {
		if x, ok := x.Message.(*GossipMessage_FinalizeRefundTimelock); ok {
			return x.FinalizeRefundTimelock
		}
	}
	return nil
}

func (x *GossipMessage) GetFinalizeNodeTimelock() *GossipMessageFinalizeRenewNodeTimelock {
	if x != nil {
		if x, ok := x.Message.(*GossipMessage_FinalizeNodeTimelock); ok {
			return x.FinalizeNodeTimelock
		}
	}
	return nil
}

type isGossipMessage_Message interface {
	isGossipMessage_Message()
}

type GossipMessage_CancelTransfer struct {
	CancelTransfer *GossipMessageCancelTransfer `protobuf:"bytes,2,opt,name=cancel_transfer,json=cancelTransfer,proto3,oneof"`
}

type GossipMessage_SettleSenderKeyTweak struct {
	SettleSenderKeyTweak *GossipMessageSettleSenderKeyTweak `protobuf:"bytes,4,opt,name=settle_sender_key_tweak,json=settleSenderKeyTweak,proto3,oneof"`
}

type GossipMessage_RollbackTransfer struct {
	RollbackTransfer *GossipMessageRollbackTransfer `protobuf:"bytes,5,opt,name=rollback_transfer,json=rollbackTransfer,proto3,oneof"`
}

type GossipMessage_MarkTreesExited struct {
	MarkTreesExited *GossipMessageMarkTreesExited `protobuf:"bytes,6,opt,name=mark_trees_exited,json=markTreesExited,proto3,oneof"`
}

type GossipMessage_FinalizeTreeCreation struct {
	FinalizeTreeCreation *GossipMessageFinalizeTreeCreation `protobuf:"bytes,7,opt,name=finalize_tree_creation,json=finalizeTreeCreation,proto3,oneof"`
}

type GossipMessage_FinalizeTransfer struct {
	FinalizeTransfer *GossipMessageFinalizeTransfer `protobuf:"bytes,8,opt,name=finalize_transfer,json=finalizeTransfer,proto3,oneof"`
}

type GossipMessage_FinalizeRefreshTimelock struct {
	FinalizeRefreshTimelock *GossipMessageFinalizeRefreshTimelock `protobuf:"bytes,9,opt,name=finalize_refresh_timelock,json=finalizeRefreshTimelock,proto3,oneof"`
}

type GossipMessage_FinalizeExtendLeaf struct {
	FinalizeExtendLeaf *GossipMessageFinalizeExtendLeaf `protobuf:"bytes,10,opt,name=finalize_extend_leaf,json=finalizeExtendLeaf,proto3,oneof"`
}

type GossipMessage_RollbackUtxoSwap struct {
	RollbackUtxoSwap *GossipMessageRollbackUtxoSwap `protobuf:"bytes,11,opt,name=rollback_utxo_swap,json=rollbackUtxoSwap,proto3,oneof"`
}

type GossipMessage_DepositCleanup struct {
	DepositCleanup *GossipMessageDepositCleanup `protobuf:"bytes,12,opt,name=deposit_cleanup,json=depositCleanup,proto3,oneof"`
}

type GossipMessage_Preimage struct {
	Preimage *GossipMessagePreimage `protobuf:"bytes,13,opt,name=preimage,proto3,oneof"`
}

type GossipMessage_FinalizeRefundTimelock struct {
	FinalizeRefundTimelock *GossipMessageFinalizeRenewRefundTimelock `protobuf:"bytes,14,opt,name=finalize_refund_timelock,json=finalizeRefundTimelock,proto3,oneof"`
}

type GossipMessage_FinalizeNodeTimelock struct {
	FinalizeNodeTimelock *GossipMessageFinalizeRenewNodeTimelock `protobuf:"bytes,15,opt,name=finalize_node_timelock,json=finalizeNodeTimelock,proto3,oneof"`
}

func (*GossipMessage_CancelTransfer) isGossipMessage_Message() {}

func (*GossipMessage_SettleSenderKeyTweak) isGossipMessage_Message() {}

func (*GossipMessage_RollbackTransfer) isGossipMessage_Message() {}

func (*GossipMessage_MarkTreesExited) isGossipMessage_Message() {}

func (*GossipMessage_FinalizeTreeCreation) isGossipMessage_Message() {}

func (*GossipMessage_FinalizeTransfer) isGossipMessage_Message() {}

func (*GossipMessage_FinalizeRefreshTimelock) isGossipMessage_Message() {}

func (*GossipMessage_FinalizeExtendLeaf) isGossipMessage_Message() {}

func (*GossipMessage_RollbackUtxoSwap) isGossipMessage_Message() {}

func (*GossipMessage_DepositCleanup) isGossipMessage_Message() {}

func (*GossipMessage_Preimage) isGossipMessage_Message() {}

func (*GossipMessage_FinalizeRefundTimelock) isGossipMessage_Message() {}

func (*GossipMessage_FinalizeNodeTimelock) isGossipMessage_Message() {}

type GossipMessageCancelTransfer struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	TransferId    string                 `protobuf:"bytes,1,opt,name=transfer_id,json=transferId,proto3" json:"transfer_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GossipMessageCancelTransfer) ProtoMessage() {}

func (x *GossipMessageCancelTransfer) ProtoReflect() protoreflect.Message {
	mi := &file_gossip_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 GossipMessageCancelTransfer.ProtoReflect.Descriptor instead.
func (*GossipMessageCancelTransfer) Descriptor() ([]byte, []int) {
	return file_gossip_proto_rawDescGZIP(), []int{1}
}

func (x *GossipMessageCancelTransfer) GetTransferId() string {
	if x != nil {
		return x.TransferId
	}
	return ""
}

// Rolling back a transfer reverts it to its initial state. Only transfers that
// have not been key-tweaked by the sender are eligible for rollback.
type GossipMessageRollbackTransfer struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	TransferId    string                 `protobuf:"bytes,1,opt,name=transfer_id,json=transferId,proto3" json:"transfer_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GossipMessageRollbackTransfer) ProtoMessage() {}

func (x *GossipMessageRollbackTransfer) ProtoReflect() protoreflect.Message {
	mi := &file_gossip_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 GossipMessageRollbackTransfer.ProtoReflect.Descriptor instead.
func (*GossipMessageRollbackTransfer) Descriptor() ([]byte, []int) {
	return file_gossip_proto_rawDescGZIP(), []int{2}
}

func (x *GossipMessageRollbackTransfer) GetTransferId() string {
	if x != nil {
		return x.TransferId
	}
	return ""
}

type GossipMessageSettleSenderKeyTweak struct {
	state      protoimpl.MessageState `protogen:"open.v1"`
	TransferId string                 `protobuf:"bytes,1,opt,name=transfer_id,json=transferId,proto3" json:"transfer_id,omitempty"`
	// The key tweak proofs for the leaves that this message is to commit.
	// This is a safe guard to ensure that we can detect mismatch key tweaks, but if the proofs
	// don't match, there's no way to recover at this point.
	SenderKeyTweakProofs map[string]*spark.SecretProof `protobuf:"bytes,2,rep,name=sender_key_tweak_proofs,json=senderKeyTweakProofs,proto3" json:"sender_key_tweak_proofs,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

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

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

func (*GossipMessageSettleSenderKeyTweak) ProtoMessage() {}

func (x *GossipMessageSettleSenderKeyTweak) ProtoReflect() protoreflect.Message {
	mi := &file_gossip_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 GossipMessageSettleSenderKeyTweak.ProtoReflect.Descriptor instead.
func (*GossipMessageSettleSenderKeyTweak) Descriptor() ([]byte, []int) {
	return file_gossip_proto_rawDescGZIP(), []int{3}
}

func (x *GossipMessageSettleSenderKeyTweak) GetTransferId() string {
	if x != nil {
		return x.TransferId
	}
	return ""
}

func (x *GossipMessageSettleSenderKeyTweak) GetSenderKeyTweakProofs() map[string]*spark.SecretProof {
	if x != nil {
		return x.SenderKeyTweakProofs
	}
	return nil
}

type GossipMessageMarkTreesExited struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	TreeIds       []string               `protobuf:"bytes,1,rep,name=tree_ids,json=treeIds,proto3" json:"tree_ids,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GossipMessageMarkTreesExited) ProtoMessage() {}

func (x *GossipMessageMarkTreesExited) ProtoReflect() protoreflect.Message {
	mi := &file_gossip_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 GossipMessageMarkTreesExited.ProtoReflect.Descriptor instead.
func (*GossipMessageMarkTreesExited) Descriptor() ([]byte, []int) {
	return file_gossip_proto_rawDescGZIP(), []int{4}
}

func (x *GossipMessageMarkTreesExited) GetTreeIds() []string {
	if x != nil {
		return x.TreeIds
	}
	return nil
}

type GossipMessageFinalizeTreeCreation struct {
	state         protoimpl.MessageState     `protogen:"open.v1"`
	InternalNodes []*spark_internal.TreeNode `protobuf:"bytes,1,rep,name=internal_nodes,json=internalNodes,proto3" json:"internal_nodes,omitempty"`
	ProtoNetwork  spark.Network              `protobuf:"varint,2,opt,name=proto_network,json=protoNetwork,proto3,enum=spark.Network" json:"proto_network,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GossipMessageFinalizeTreeCreation) ProtoMessage() {}

func (x *GossipMessageFinalizeTreeCreation) ProtoReflect() protoreflect.Message {
	mi := &file_gossip_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 GossipMessageFinalizeTreeCreation.ProtoReflect.Descriptor instead.
func (*GossipMessageFinalizeTreeCreation) Descriptor() ([]byte, []int) {
	return file_gossip_proto_rawDescGZIP(), []int{5}
}

func (x *GossipMessageFinalizeTreeCreation) GetInternalNodes() []*spark_internal.TreeNode {
	if x != nil {
		return x.InternalNodes
	}
	return nil
}

func (x *GossipMessageFinalizeTreeCreation) GetProtoNetwork() spark.Network {
	if x != nil {
		return x.ProtoNetwork
	}
	return spark.Network(0)
}

type GossipMessageFinalizeTransfer struct {
	state               protoimpl.MessageState     `protogen:"open.v1"`
	TransferId          string                     `protobuf:"bytes,1,opt,name=transfer_id,json=transferId,proto3" json:"transfer_id,omitempty"`
	InternalNodes       []*spark_internal.TreeNode `protobuf:"bytes,2,rep,name=internal_nodes,json=internalNodes,proto3" json:"internal_nodes,omitempty"`
	CompletionTimestamp *timestamppb.Timestamp     `protobuf:"bytes,3,opt,name=completion_timestamp,json=completionTimestamp,proto3" json:"completion_timestamp,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

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

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

func (*GossipMessageFinalizeTransfer) ProtoMessage() {}

func (x *GossipMessageFinalizeTransfer) ProtoReflect() protoreflect.Message {
	mi := &file_gossip_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 GossipMessageFinalizeTransfer.ProtoReflect.Descriptor instead.
func (*GossipMessageFinalizeTransfer) Descriptor() ([]byte, []int) {
	return file_gossip_proto_rawDescGZIP(), []int{6}
}

func (x *GossipMessageFinalizeTransfer) GetTransferId() string {
	if x != nil {
		return x.TransferId
	}
	return ""
}

func (x *GossipMessageFinalizeTransfer) GetInternalNodes() []*spark_internal.TreeNode {
	if x != nil {
		return x.InternalNodes
	}
	return nil
}

func (x *GossipMessageFinalizeTransfer) GetCompletionTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.CompletionTimestamp
	}
	return nil
}

type GossipMessageFinalizeRefreshTimelock struct {
	state         protoimpl.MessageState     `protogen:"open.v1"`
	InternalNodes []*spark_internal.TreeNode `protobuf:"bytes,1,rep,name=internal_nodes,json=internalNodes,proto3" json:"internal_nodes,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GossipMessageFinalizeRefreshTimelock) ProtoMessage() {}

func (x *GossipMessageFinalizeRefreshTimelock) ProtoReflect() protoreflect.Message {
	mi := &file_gossip_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 GossipMessageFinalizeRefreshTimelock.ProtoReflect.Descriptor instead.
func (*GossipMessageFinalizeRefreshTimelock) Descriptor() ([]byte, []int) {
	return file_gossip_proto_rawDescGZIP(), []int{7}
}

func (x *GossipMessageFinalizeRefreshTimelock) GetInternalNodes() []*spark_internal.TreeNode {
	if x != nil {
		return x.InternalNodes
	}
	return nil
}

type GossipMessageFinalizeExtendLeaf struct {
	state         protoimpl.MessageState     `protogen:"open.v1"`
	InternalNodes []*spark_internal.TreeNode `protobuf:"bytes,1,rep,name=internal_nodes,json=internalNodes,proto3" json:"internal_nodes,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GossipMessageFinalizeExtendLeaf) ProtoMessage() {}

func (x *GossipMessageFinalizeExtendLeaf) ProtoReflect() protoreflect.Message {
	mi := &file_gossip_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 GossipMessageFinalizeExtendLeaf.ProtoReflect.Descriptor instead.
func (*GossipMessageFinalizeExtendLeaf) Descriptor() ([]byte, []int) {
	return file_gossip_proto_rawDescGZIP(), []int{8}
}

func (x *GossipMessageFinalizeExtendLeaf) GetInternalNodes() []*spark_internal.TreeNode {
	if x != nil {
		return x.InternalNodes
	}
	return nil
}

type GossipMessageFinalizeRenewRefundTimelock struct {
	state         protoimpl.MessageState   `protogen:"open.v1"`
	Node          *spark_internal.TreeNode `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GossipMessageFinalizeRenewRefundTimelock) ProtoMessage() {}

func (x *GossipMessageFinalizeRenewRefundTimelock) ProtoReflect() protoreflect.Message {
	mi := &file_gossip_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 GossipMessageFinalizeRenewRefundTimelock.ProtoReflect.Descriptor instead.
func (*GossipMessageFinalizeRenewRefundTimelock) Descriptor() ([]byte, []int) {
	return file_gossip_proto_rawDescGZIP(), []int{9}
}

func (x *GossipMessageFinalizeRenewRefundTimelock) GetNode() *spark_internal.TreeNode {
	if x != nil {
		return x.Node
	}
	return nil
}

type GossipMessageFinalizeRenewNodeTimelock struct {
	state         protoimpl.MessageState   `protogen:"open.v1"`
	SplitNode     *spark_internal.TreeNode `protobuf:"bytes,1,opt,name=split_node,json=splitNode,proto3" json:"split_node,omitempty"`
	Node          *spark_internal.TreeNode `protobuf:"bytes,2,opt,name=node,proto3" json:"node,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GossipMessageFinalizeRenewNodeTimelock) ProtoMessage() {}

func (x *GossipMessageFinalizeRenewNodeTimelock) ProtoReflect() protoreflect.Message {
	mi := &file_gossip_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 GossipMessageFinalizeRenewNodeTimelock.ProtoReflect.Descriptor instead.
func (*GossipMessageFinalizeRenewNodeTimelock) Descriptor() ([]byte, []int) {
	return file_gossip_proto_rawDescGZIP(), []int{10}
}

func (x *GossipMessageFinalizeRenewNodeTimelock) GetSplitNode() *spark_internal.TreeNode {
	if x != nil {
		return x.SplitNode
	}
	return nil
}

func (x *GossipMessageFinalizeRenewNodeTimelock) GetNode() *spark_internal.TreeNode {
	if x != nil {
		return x.Node
	}
	return nil
}

// Rollback UTXO swap is called when Create UTXO swap transaction failed to
// fully complete. This reverts the state back to before the swap, allowing the
// user to initiate the UTXO swap again.
type GossipMessageRollbackUtxoSwap struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// UTXO swap is identified by UTXO
	OnChainUtxo *spark.UTXO `protobuf:"bytes,1,opt,name=on_chain_utxo,json=onChainUtxo,proto3" json:"on_chain_utxo,omitempty"`
	// Signature of the Coordinator that started the Create UTXO swap transaction
	Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	// Identity key of the Coordinator
	CoordinatorPublicKey []byte `protobuf:"bytes,3,opt,name=coordinator_public_key,json=coordinatorPublicKey,proto3" json:"coordinator_public_key,omitempty"`
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

func (x *GossipMessageRollbackUtxoSwap) Reset() {
	*x = GossipMessageRollbackUtxoSwap{}
	mi := &file_gossip_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GossipMessageRollbackUtxoSwap) ProtoMessage() {}

func (x *GossipMessageRollbackUtxoSwap) ProtoReflect() protoreflect.Message {
	mi := &file_gossip_proto_msgTypes[11]
	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 GossipMessageRollbackUtxoSwap.ProtoReflect.Descriptor instead.
func (*GossipMessageRollbackUtxoSwap) Descriptor() ([]byte, []int) {
	return file_gossip_proto_rawDescGZIP(), []int{11}
}

func (x *GossipMessageRollbackUtxoSwap) GetOnChainUtxo() *spark.UTXO {
	if x != nil {
		return x.OnChainUtxo
	}
	return nil
}

func (x *GossipMessageRollbackUtxoSwap) GetSignature() []byte {
	if x != nil {
		return x.Signature
	}
	return nil
}

func (x *GossipMessageRollbackUtxoSwap) GetCoordinatorPublicKey() []byte {
	if x != nil {
		return x.CoordinatorPublicKey
	}
	return nil
}

type GossipMessageDepositCleanup struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	TreeId        string                 `protobuf:"bytes,1,opt,name=tree_id,json=treeId,proto3" json:"tree_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GossipMessageDepositCleanup) Reset() {
	*x = GossipMessageDepositCleanup{}
	mi := &file_gossip_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GossipMessageDepositCleanup) ProtoMessage() {}

func (x *GossipMessageDepositCleanup) ProtoReflect() protoreflect.Message {
	mi := &file_gossip_proto_msgTypes[12]
	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 GossipMessageDepositCleanup.ProtoReflect.Descriptor instead.
func (*GossipMessageDepositCleanup) Descriptor() ([]byte, []int) {
	return file_gossip_proto_rawDescGZIP(), []int{12}
}

func (x *GossipMessageDepositCleanup) GetTreeId() string {
	if x != nil {
		return x.TreeId
	}
	return ""
}

type GossipMessagePreimage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Preimage      []byte                 `protobuf:"bytes,1,opt,name=preimage,proto3" json:"preimage,omitempty"`
	PaymentHash   []byte                 `protobuf:"bytes,2,opt,name=payment_hash,json=paymentHash,proto3" json:"payment_hash,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GossipMessagePreimage) Reset() {
	*x = GossipMessagePreimage{}
	mi := &file_gossip_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GossipMessagePreimage) ProtoMessage() {}

func (x *GossipMessagePreimage) ProtoReflect() protoreflect.Message {
	mi := &file_gossip_proto_msgTypes[13]
	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 GossipMessagePreimage.ProtoReflect.Descriptor instead.
func (*GossipMessagePreimage) Descriptor() ([]byte, []int) {
	return file_gossip_proto_rawDescGZIP(), []int{13}
}

func (x *GossipMessagePreimage) GetPreimage() []byte {
	if x != nil {
		return x.Preimage
	}
	return nil
}

func (x *GossipMessagePreimage) GetPaymentHash() []byte {
	if x != nil {
		return x.PaymentHash
	}
	return nil
}

var File_gossip_proto protoreflect.FileDescriptor

const file_gossip_proto_rawDesc = "" +
	"\n" +
	"\fgossip.proto\x12\x06gossip\x1a\vspark.proto\x1a\fcommon.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x14spark_internal.proto\x1a\x1bgoogle/protobuf/empty.proto\"\xd9\t\n" +
	"\rGossipMessage\x12\x1d\n" +
	"\n" +
	"message_id\x18\x01 \x01(\tR\tmessageId\x12N\n" +
	"\x0fcancel_transfer\x18\x02 \x01(\v2#.gossip.GossipMessageCancelTransferH\x00R\x0ecancelTransfer\x12b\n" +
	"\x17settle_sender_key_tweak\x18\x04 \x01(\v2).gossip.GossipMessageSettleSenderKeyTweakH\x00R\x14settleSenderKeyTweak\x12T\n" +
	"\x11rollback_transfer\x18\x05 \x01(\v2%.gossip.GossipMessageRollbackTransferH\x00R\x10rollbackTransfer\x12R\n" +
	"\x11mark_trees_exited\x18\x06 \x01(\v2$.gossip.GossipMessageMarkTreesExitedH\x00R\x0fmarkTreesExited\x12a\n" +
	"\x16finalize_tree_creation\x18\a \x01(\v2).gossip.GossipMessageFinalizeTreeCreationH\x00R\x14finalizeTreeCreation\x12T\n" +
	"\x11finalize_transfer\x18\b \x01(\v2%.gossip.GossipMessageFinalizeTransferH\x00R\x10finalizeTransfer\x12j\n" +
	"\x19finalize_refresh_timelock\x18\t \x01(\v2,.gossip.GossipMessageFinalizeRefreshTimelockH\x00R\x17finalizeRefreshTimelock\x12[\n" +
	"\x14finalize_extend_leaf\x18\n" +
	" \x01(\v2'.gossip.GossipMessageFinalizeExtendLeafH\x00R\x12finalizeExtendLeaf\x12U\n" +
	"\x12rollback_utxo_swap\x18\v \x01(\v2%.gossip.GossipMessageRollbackUtxoSwapH\x00R\x10rollbackUtxoSwap\x12N\n" +
	"\x0fdeposit_cleanup\x18\f \x01(\v2#.gossip.GossipMessageDepositCleanupH\x00R\x0edepositCleanup\x12;\n" +
	"\bpreimage\x18\r \x01(\v2\x1d.gossip.GossipMessagePreimageH\x00R\bpreimage\x12l\n" +
	"\x18finalize_refund_timelock\x18\x0e \x01(\v20.gossip.GossipMessageFinalizeRenewRefundTimelockH\x00R\x16finalizeRefundTimelock\x12f\n" +
	"\x16finalize_node_timelock\x18\x0f \x01(\v2..gossip.GossipMessageFinalizeRenewNodeTimelockH\x00R\x14finalizeNodeTimelockB\t\n" +
	"\amessageJ\x04\b\x03\x10\x04\">\n" +
	"\x1bGossipMessageCancelTransfer\x12\x1f\n" +
	"\vtransfer_id\x18\x01 \x01(\tR\n" +
	"transferId\"@\n" +
	"\x1dGossipMessageRollbackTransfer\x12\x1f\n" +
	"\vtransfer_id\x18\x01 \x01(\tR\n" +
	"transferId\"\x9d\x02\n" +
	"!GossipMessageSettleSenderKeyTweak\x12\x1f\n" +
	"\vtransfer_id\x18\x01 \x01(\tR\n" +
	"transferId\x12z\n" +
	"\x17sender_key_tweak_proofs\x18\x02 \x03(\v2C.gossip.GossipMessageSettleSenderKeyTweak.SenderKeyTweakProofsEntryR\x14senderKeyTweakProofs\x1a[\n" +
	"\x19SenderKeyTweakProofsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12(\n" +
	"\x05value\x18\x02 \x01(\v2\x12.spark.SecretProofR\x05value:\x028\x01\"9\n" +
	"\x1cGossipMessageMarkTreesExited\x12\x19\n" +
	"\btree_ids\x18\x01 \x03(\tR\atreeIds\"\x99\x01\n" +
	"!GossipMessageFinalizeTreeCreation\x12?\n" +
	"\x0einternal_nodes\x18\x01 \x03(\v2\x18.spark_internal.TreeNodeR\rinternalNodes\x123\n" +
	"\rproto_network\x18\x02 \x01(\x0e2\x0e.spark.NetworkR\fprotoNetwork\"\xd0\x01\n" +
	"\x1dGossipMessageFinalizeTransfer\x12\x1f\n" +
	"\vtransfer_id\x18\x01 \x01(\tR\n" +
	"transferId\x12?\n" +
	"\x0einternal_nodes\x18\x02 \x03(\v2\x18.spark_internal.TreeNodeR\rinternalNodes\x12M\n" +
	"\x14completion_timestamp\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\x13completionTimestamp\"g\n" +
	"$GossipMessageFinalizeRefreshTimelock\x12?\n" +
	"\x0einternal_nodes\x18\x01 \x03(\v2\x18.spark_internal.TreeNodeR\rinternalNodes\"b\n" +
	"\x1fGossipMessageFinalizeExtendLeaf\x12?\n" +
	"\x0einternal_nodes\x18\x01 \x03(\v2\x18.spark_internal.TreeNodeR\rinternalNodes\"X\n" +
	"(GossipMessageFinalizeRenewRefundTimelock\x12,\n" +
	"\x04node\x18\x01 \x01(\v2\x18.spark_internal.TreeNodeR\x04node\"\x8f\x01\n" +
	"&GossipMessageFinalizeRenewNodeTimelock\x127\n" +
	"\n" +
	"split_node\x18\x01 \x01(\v2\x18.spark_internal.TreeNodeR\tsplitNode\x12,\n" +
	"\x04node\x18\x02 \x01(\v2\x18.spark_internal.TreeNodeR\x04node\"\xa4\x01\n" +
	"\x1dGossipMessageRollbackUtxoSwap\x12/\n" +
	"\ron_chain_utxo\x18\x01 \x01(\v2\v.spark.UTXOR\vonChainUtxo\x12\x1c\n" +
	"\tsignature\x18\x02 \x01(\fR\tsignature\x124\n" +
	"\x16coordinator_public_key\x18\x03 \x01(\fR\x14coordinatorPublicKey\"6\n" +
	"\x1bGossipMessageDepositCleanup\x12\x17\n" +
	"\atree_id\x18\x01 \x01(\tR\x06treeId\"V\n" +
	"\x15GossipMessagePreimage\x12\x1a\n" +
	"\bpreimage\x18\x01 \x01(\fR\bpreimage\x12!\n" +
	"\fpayment_hash\x18\x02 \x01(\fR\vpaymentHash2H\n" +
	"\rGossipService\x127\n" +
	"\x06gossip\x12\x15.gossip.GossipMessage\x1a\x16.google.protobuf.EmptyB-Z+github.com/lightsparkdev/spark/proto/gossipb\x06proto3"

var (
	file_gossip_proto_rawDescOnce sync.Once
	file_gossip_proto_rawDescData []byte
)

func file_gossip_proto_rawDescGZIP() []byte {
	file_gossip_proto_rawDescOnce.Do(func() {
		file_gossip_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_gossip_proto_rawDesc), len(file_gossip_proto_rawDesc)))
	})
	return file_gossip_proto_rawDescData
}

var file_gossip_proto_msgTypes = make([]protoimpl.MessageInfo, 15)
var file_gossip_proto_goTypes = []any{
	(*GossipMessage)(nil),                            // 0: gossip.GossipMessage
	(*GossipMessageCancelTransfer)(nil),              // 1: gossip.GossipMessageCancelTransfer
	(*GossipMessageRollbackTransfer)(nil),            // 2: gossip.GossipMessageRollbackTransfer
	(*GossipMessageSettleSenderKeyTweak)(nil),        // 3: gossip.GossipMessageSettleSenderKeyTweak
	(*GossipMessageMarkTreesExited)(nil),             // 4: gossip.GossipMessageMarkTreesExited
	(*GossipMessageFinalizeTreeCreation)(nil),        // 5: gossip.GossipMessageFinalizeTreeCreation
	(*GossipMessageFinalizeTransfer)(nil),            // 6: gossip.GossipMessageFinalizeTransfer
	(*GossipMessageFinalizeRefreshTimelock)(nil),     // 7: gossip.GossipMessageFinalizeRefreshTimelock
	(*GossipMessageFinalizeExtendLeaf)(nil),          // 8: gossip.GossipMessageFinalizeExtendLeaf
	(*GossipMessageFinalizeRenewRefundTimelock)(nil), // 9: gossip.GossipMessageFinalizeRenewRefundTimelock
	(*GossipMessageFinalizeRenewNodeTimelock)(nil),   // 10: gossip.GossipMessageFinalizeRenewNodeTimelock
	(*GossipMessageRollbackUtxoSwap)(nil),            // 11: gossip.GossipMessageRollbackUtxoSwap
	(*GossipMessageDepositCleanup)(nil),              // 12: gossip.GossipMessageDepositCleanup
	(*GossipMessagePreimage)(nil),                    // 13: gossip.GossipMessagePreimage
	nil,                                              // 14: gossip.GossipMessageSettleSenderKeyTweak.SenderKeyTweakProofsEntry
	(*spark_internal.TreeNode)(nil),                  // 15: spark_internal.TreeNode
	(spark.Network)(0),                               // 16: spark.Network
	(*timestamppb.Timestamp)(nil),                    // 17: google.protobuf.Timestamp
	(*spark.UTXO)(nil),                               // 18: spark.UTXO
	(*spark.SecretProof)(nil),                        // 19: spark.SecretProof
	(*emptypb.Empty)(nil),                            // 20: google.protobuf.Empty
}
var file_gossip_proto_depIdxs = []int32{
	1,  // 0: gossip.GossipMessage.cancel_transfer:type_name -> gossip.GossipMessageCancelTransfer
	3,  // 1: gossip.GossipMessage.settle_sender_key_tweak:type_name -> gossip.GossipMessageSettleSenderKeyTweak
	2,  // 2: gossip.GossipMessage.rollback_transfer:type_name -> gossip.GossipMessageRollbackTransfer
	4,  // 3: gossip.GossipMessage.mark_trees_exited:type_name -> gossip.GossipMessageMarkTreesExited
	5,  // 4: gossip.GossipMessage.finalize_tree_creation:type_name -> gossip.GossipMessageFinalizeTreeCreation
	6,  // 5: gossip.GossipMessage.finalize_transfer:type_name -> gossip.GossipMessageFinalizeTransfer
	7,  // 6: gossip.GossipMessage.finalize_refresh_timelock:type_name -> gossip.GossipMessageFinalizeRefreshTimelock
	8,  // 7: gossip.GossipMessage.finalize_extend_leaf:type_name -> gossip.GossipMessageFinalizeExtendLeaf
	11, // 8: gossip.GossipMessage.rollback_utxo_swap:type_name -> gossip.GossipMessageRollbackUtxoSwap
	12, // 9: gossip.GossipMessage.deposit_cleanup:type_name -> gossip.GossipMessageDepositCleanup
	13, // 10: gossip.GossipMessage.preimage:type_name -> gossip.GossipMessagePreimage
	9,  // 11: gossip.GossipMessage.finalize_refund_timelock:type_name -> gossip.GossipMessageFinalizeRenewRefundTimelock
	10, // 12: gossip.GossipMessage.finalize_node_timelock:type_name -> gossip.GossipMessageFinalizeRenewNodeTimelock
	14, // 13: gossip.GossipMessageSettleSenderKeyTweak.sender_key_tweak_proofs:type_name -> gossip.GossipMessageSettleSenderKeyTweak.SenderKeyTweakProofsEntry
	15, // 14: gossip.GossipMessageFinalizeTreeCreation.internal_nodes:type_name -> spark_internal.TreeNode
	16, // 15: gossip.GossipMessageFinalizeTreeCreation.proto_network:type_name -> spark.Network
	15, // 16: gossip.GossipMessageFinalizeTransfer.internal_nodes:type_name -> spark_internal.TreeNode
	17, // 17: gossip.GossipMessageFinalizeTransfer.completion_timestamp:type_name -> google.protobuf.Timestamp
	15, // 18: gossip.GossipMessageFinalizeRefreshTimelock.internal_nodes:type_name -> spark_internal.TreeNode
	15, // 19: gossip.GossipMessageFinalizeExtendLeaf.internal_nodes:type_name -> spark_internal.TreeNode
	15, // 20: gossip.GossipMessageFinalizeRenewRefundTimelock.node:type_name -> spark_internal.TreeNode
	15, // 21: gossip.GossipMessageFinalizeRenewNodeTimelock.split_node:type_name -> spark_internal.TreeNode
	15, // 22: gossip.GossipMessageFinalizeRenewNodeTimelock.node:type_name -> spark_internal.TreeNode
	18, // 23: gossip.GossipMessageRollbackUtxoSwap.on_chain_utxo:type_name -> spark.UTXO
	19, // 24: gossip.GossipMessageSettleSenderKeyTweak.SenderKeyTweakProofsEntry.value:type_name -> spark.SecretProof
	0,  // 25: gossip.GossipService.gossip:input_type -> gossip.GossipMessage
	20, // 26: gossip.GossipService.gossip:output_type -> google.protobuf.Empty
	26, // [26:27] is the sub-list for method output_type
	25, // [25:26] is the sub-list for method input_type
	25, // [25:25] is the sub-list for extension type_name
	25, // [25:25] is the sub-list for extension extendee
	0,  // [0:25] is the sub-list for field type_name
}

func init() { file_gossip_proto_init() }
func file_gossip_proto_init() {
	if File_gossip_proto != nil {
		return
	}
	file_gossip_proto_msgTypes[0].OneofWrappers = []any{
		(*GossipMessage_CancelTransfer)(nil),
		(*GossipMessage_SettleSenderKeyTweak)(nil),
		(*GossipMessage_RollbackTransfer)(nil),
		(*GossipMessage_MarkTreesExited)(nil),
		(*GossipMessage_FinalizeTreeCreation)(nil),
		(*GossipMessage_FinalizeTransfer)(nil),
		(*GossipMessage_FinalizeRefreshTimelock)(nil),
		(*GossipMessage_FinalizeExtendLeaf)(nil),
		(*GossipMessage_RollbackUtxoSwap)(nil),
		(*GossipMessage_DepositCleanup)(nil),
		(*GossipMessage_Preimage)(nil),
		(*GossipMessage_FinalizeRefundTimelock)(nil),
		(*GossipMessage_FinalizeNodeTimelock)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_gossip_proto_rawDesc), len(file_gossip_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   15,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_gossip_proto_goTypes,
		DependencyIndexes: file_gossip_proto_depIdxs,
		MessageInfos:      file_gossip_proto_msgTypes,
	}.Build()
	File_gossip_proto = out.File
	file_gossip_proto_goTypes = nil
	file_gossip_proto_depIdxs = nil
}
