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

package lib

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)
)

// *****************************************************************************************************
// This file is auto-generated from source files in `/lib/.proto/*` using Protocol Buffers (protobuf)
//
// Protobuf is a language-neutral, platform-neutral serialization format. It allows users
// to define objects in a way that’s both efficient to store and fast to transmit over the network.
// These definitions are compiled into code that *enables different systems and programming languages
// to communicate in a byte-perfect manner*
//
// To update these structures, make changes to the source .proto files, then recompile
// to regenerate this file.
// These auto-generated files are easily recognized by checking for a `.pb.go` ending
// *****************************************************************************************************
// _
// _
// _
// Topic: an identifier used to organize and manage different streams of data within a single communication channel
// It allows multiple, independent message streams to be handled simultaneously over the same connection
// It's ordered by stream priority
// IMPORTANT: if adding a new topic remember to also add it to the select statement in startSendService() in p2p/conn.go
type Topic int32

const (
	// CONSENSUS: topic for the BFT process
	Topic_CONSENSUS Topic = 0
	// BLOCK: topic for an inbound block and certificate
	Topic_BLOCK Topic = 1
	// BLOCK_REQUEST: topic for a peer requesting a certain block and certificate
	Topic_BLOCK_REQUEST Topic = 2
	// TX: topic for an inbound transaction
	Topic_TX Topic = 3
	// PEERS_RESPONSE: topic for a response to a peer exchange request
	Topic_PEERS_RESPONSE Topic = 4
	// PEERS_REQUEST: topic a peer requesting an exchange of book peers
	Topic_PEERS_REQUEST Topic = 5
	// INVALID: topic to mark the exclusive end of valid topics
	Topic_INVALID Topic = 6
)

// Enum value maps for Topic.
var (
	Topic_name = map[int32]string{
		0: "CONSENSUS",
		1: "BLOCK",
		2: "BLOCK_REQUEST",
		3: "TX",
		4: "PEERS_RESPONSE",
		5: "PEERS_REQUEST",
		6: "INVALID",
	}
	Topic_value = map[string]int32{
		"CONSENSUS":      0,
		"BLOCK":          1,
		"BLOCK_REQUEST":  2,
		"TX":             3,
		"PEERS_RESPONSE": 4,
		"PEERS_REQUEST":  5,
		"INVALID":        6,
	}
)

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

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

func (Topic) Descriptor() protoreflect.EnumDescriptor {
	return file_peer_proto_enumTypes[0].Descriptor()
}

func (Topic) Type() protoreflect.EnumType {
	return &file_peer_proto_enumTypes[0]
}

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

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

// PeerInfo contains peering information about a peer node, like its address, connection type, trust level,
// and reputation
type PeerInfo struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Address: the address information of the peer, including its public key and network address
	Address *PeerAddress `protobuf:"bytes,1,opt,name=Address,proto3" json:"address"` // @gotags: json:"address"
	// is_outbound: indicates whether the connection to the peer was initiated by this node (true if outbound)
	IsOutbound bool `protobuf:"varint,2,opt,name=is_outbound,json=isOutbound,proto3" json:"isOutbound"` // @gotags: json:"isOutbound"
	// is_must_connect: indicates whether this peer is a required connection that the node must connect to
	IsMustConnect bool `protobuf:"varint,3,opt,name=is_must_connect,json=isMustConnect,proto3" json:"isMustConnect"` // @gotags: json:"isMustConnect"
	// is_trusted: marks whether this peer is configured as trusted
	IsTrusted bool `protobuf:"varint,4,opt,name=is_trusted,json=isTrusted,proto3" json:"isTrusted"` // @gotags: json:"isTrusted"
	// reputation: a numerical score representing the peer's reputation to this local node
	Reputation    int32 `protobuf:"varint,5,opt,name=reputation,proto3" json:"reputation,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PeerInfo) ProtoMessage() {}

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

func (x *PeerInfo) GetAddress() *PeerAddress {
	if x != nil {
		return x.Address
	}
	return nil
}

func (x *PeerInfo) GetIsOutbound() bool {
	if x != nil {
		return x.IsOutbound
	}
	return false
}

func (x *PeerInfo) GetIsMustConnect() bool {
	if x != nil {
		return x.IsMustConnect
	}
	return false
}

func (x *PeerInfo) GetIsTrusted() bool {
	if x != nil {
		return x.IsTrusted
	}
	return false
}

func (x *PeerInfo) GetReputation() int32 {
	if x != nil {
		return x.Reputation
	}
	return 0
}

// PeerAddress holds the details of the peer's network address and public key
type PeerAddress struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// public_key: the peer's public key used for cryptographic identity
	PublicKey []byte `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"publicKey"` // @gotags: json:"publicKey"
	// net_address: the tcp network address of the peer Ex. tcp://8.8.8.8:8080 or 8.8.8.8:8080
	NetAddress string `protobuf:"bytes,2,opt,name=net_address,json=netAddress,proto3" json:"netAddress"` // @gotags: json:"netAddress"
	// peer_meta: additional metadata about the peer, such as the network ID and chains it supports
	PeerMeta      *PeerMeta `protobuf:"bytes,3,opt,name=peer_meta,json=peerMeta,proto3" json:"peerMeta"` // @gotags: json:"peerMeta"
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PeerAddress) ProtoMessage() {}

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

func (x *PeerAddress) GetPublicKey() []byte {
	if x != nil {
		return x.PublicKey
	}
	return nil
}

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

func (x *PeerAddress) GetPeerMeta() *PeerMeta {
	if x != nil {
		return x.PeerMeta
	}
	return nil
}

// PeerMeta contains additional metadata about a peer, including supported networks and chains
type PeerMeta struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// network_id: the identifier for the network the peer is part of
	// this ensures no conflicts among different peering networks (mainnet, testnet, etc.)
	NetworkId uint64 `protobuf:"varint,1,opt,name=network_id,json=networkId,proto3" json:"networkID"` // @gotags: json:"networkID"
	// chain_id the chain identifiers that the peer supports and/or participates in
	ChainId uint64 `protobuf:"varint,2,opt,name=chain_id,json=chainId,proto3" json:"chainID"` // @gotags: json:"chainID"
	// signature: a cryptographic signature to verify the authenticity of the peer's metadata
	Signature     []byte `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PeerMeta) ProtoMessage() {}

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

func (x *PeerMeta) GetNetworkId() uint64 {
	if x != nil {
		return x.NetworkId
	}
	return 0
}

func (x *PeerMeta) GetChainId() uint64 {
	if x != nil {
		return x.ChainId
	}
	return 0
}

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

// BlockRequestMessage is a p2p message payload that is requesting a block and/or max_height of the peer
type BlockRequestMessage struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// chain_id: is the unique identifier of the committee associated with this message
	ChainId uint64 `protobuf:"varint,1,opt,name=chain_id,json=chainId,proto3" json:"chainID"` // @gotags: json:"chainID"
	// height: the height of the block being requested
	Height uint64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
	// height_only: signals if this is a max-height only request, no block is expected in the response to this type
	// of message
	HeightOnly    bool `protobuf:"varint,3,opt,name=height_only,json=heightOnly,proto3" json:"heightOnly"` // @gotags: json:"heightOnly"
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BlockRequestMessage) ProtoMessage() {}

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

func (x *BlockRequestMessage) GetChainId() uint64 {
	if x != nil {
		return x.ChainId
	}
	return 0
}

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

func (x *BlockRequestMessage) GetHeightOnly() bool {
	if x != nil {
		return x.HeightOnly
	}
	return false
}

// BlockMessage is a p2p message payload that is responding to a block request message
type BlockMessage struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// chain_id: is the unique identifier of the committee associated with this message
	ChainId uint64 `protobuf:"varint,1,opt,name=chain_id,json=chainId,proto3" json:"chainID"` // @gotags: json:"chainID"
	// max_height: the maximum height of this blockchain the peer is aware of
	MaxHeight uint64 `protobuf:"varint,2,opt,name=max_height,json=maxHeight,proto3" json:"maxHeight"` // @gotags: json:"maxHeight"
	// total_vdf_iterations: the total number of vdf iterations associated with this blockchain
	// this helps a peer to chose given a choice between two forks as well as verify the integrity of the peer
	TotalVdfIterations uint64 `protobuf:"varint,3,opt,name=total_vdf_iterations,json=totalVdfIterations,proto3" json:"totalVDFIterations"` // @gotags: json:"totalVDFIterations"
	// block_and_certificate: is the actual block and the super-majority signed quorum certificate that justifies it
	BlockAndCertificate *QuorumCertificate `protobuf:"bytes,4,opt,name=BlockAndCertificate,proto3" json:"blockAndCertificate"` // @gotags: json:"blockAndCertificate"
	// timestamp: optional timestamp to help coordinate new height
	Time          uint64 `protobuf:"varint,5,opt,name=time,proto3" json:"time,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BlockMessage) ProtoMessage() {}

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

func (x *BlockMessage) GetChainId() uint64 {
	if x != nil {
		return x.ChainId
	}
	return 0
}

func (x *BlockMessage) GetMaxHeight() uint64 {
	if x != nil {
		return x.MaxHeight
	}
	return 0
}

func (x *BlockMessage) GetTotalVdfIterations() uint64 {
	if x != nil {
		return x.TotalVdfIterations
	}
	return 0
}

func (x *BlockMessage) GetBlockAndCertificate() *QuorumCertificate {
	if x != nil {
		return x.BlockAndCertificate
	}
	return nil
}

func (x *BlockMessage) GetTime() uint64 {
	if x != nil {
		return x.Time
	}
	return 0
}

// TxMessage is a p2p message payload that is an inbound transaction to be processed by the blockchain's FSM and saved
// in that chains mempool
type TxMessage struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// chain_id: is the unique identifier of the committee associated with this message
	ChainId uint64 `protobuf:"varint,1,opt,name=chain_id,json=chainId,proto3" json:"chainID"` // @gotags: json:"chainID"
	// txs: is the bytes of the transactions that may be unmarshalled into a Transaction object
	Txs           [][]byte `protobuf:"bytes,2,rep,name=txs,proto3" json:"txs,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TxMessage) ProtoMessage() {}

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

func (x *TxMessage) GetChainId() uint64 {
	if x != nil {
		return x.ChainId
	}
	return 0
}

func (x *TxMessage) GetTxs() [][]byte {
	if x != nil {
		return x.Txs
	}
	return nil
}

var File_peer_proto protoreflect.FileDescriptor

const file_peer_proto_rawDesc = "" +
	"\n" +
	"\n" +
	"peer.proto\x12\x05types\x1a\x11certificate.proto\"\xc0\x01\n" +
	"\bPeerInfo\x12,\n" +
	"\aAddress\x18\x01 \x01(\v2\x12.types.PeerAddressR\aAddress\x12\x1f\n" +
	"\vis_outbound\x18\x02 \x01(\bR\n" +
	"isOutbound\x12&\n" +
	"\x0fis_must_connect\x18\x03 \x01(\bR\risMustConnect\x12\x1d\n" +
	"\n" +
	"is_trusted\x18\x04 \x01(\bR\tisTrusted\x12\x1e\n" +
	"\n" +
	"reputation\x18\x05 \x01(\x05R\n" +
	"reputation\"{\n" +
	"\vPeerAddress\x12\x1d\n" +
	"\n" +
	"public_key\x18\x01 \x01(\fR\tpublicKey\x12\x1f\n" +
	"\vnet_address\x18\x02 \x01(\tR\n" +
	"netAddress\x12,\n" +
	"\tpeer_meta\x18\x03 \x01(\v2\x0f.types.PeerMetaR\bpeerMeta\"b\n" +
	"\bPeerMeta\x12\x1d\n" +
	"\n" +
	"network_id\x18\x01 \x01(\x04R\tnetworkId\x12\x19\n" +
	"\bchain_id\x18\x02 \x01(\x04R\achainId\x12\x1c\n" +
	"\tsignature\x18\x03 \x01(\fR\tsignature\"i\n" +
	"\x13BlockRequestMessage\x12\x19\n" +
	"\bchain_id\x18\x01 \x01(\x04R\achainId\x12\x16\n" +
	"\x06height\x18\x02 \x01(\x04R\x06height\x12\x1f\n" +
	"\vheight_only\x18\x03 \x01(\bR\n" +
	"heightOnly\"\xda\x01\n" +
	"\fBlockMessage\x12\x19\n" +
	"\bchain_id\x18\x01 \x01(\x04R\achainId\x12\x1d\n" +
	"\n" +
	"max_height\x18\x02 \x01(\x04R\tmaxHeight\x120\n" +
	"\x14total_vdf_iterations\x18\x03 \x01(\x04R\x12totalVdfIterations\x12J\n" +
	"\x13BlockAndCertificate\x18\x04 \x01(\v2\x18.types.QuorumCertificateR\x13BlockAndCertificate\x12\x12\n" +
	"\x04time\x18\x05 \x01(\x04R\x04time\"8\n" +
	"\tTxMessage\x12\x19\n" +
	"\bchain_id\x18\x01 \x01(\x04R\achainId\x12\x10\n" +
	"\x03txs\x18\x02 \x03(\fR\x03txs*p\n" +
	"\x05Topic\x12\r\n" +
	"\tCONSENSUS\x10\x00\x12\t\n" +
	"\x05BLOCK\x10\x01\x12\x11\n" +
	"\rBLOCK_REQUEST\x10\x02\x12\x06\n" +
	"\x02TX\x10\x03\x12\x12\n" +
	"\x0ePEERS_RESPONSE\x10\x04\x12\x11\n" +
	"\rPEERS_REQUEST\x10\x05\x12\v\n" +
	"\aINVALID\x10\x06B&Z$github.com/canopy-network/canopy/libb\x06proto3"

var (
	file_peer_proto_rawDescOnce sync.Once
	file_peer_proto_rawDescData []byte
)

func file_peer_proto_rawDescGZIP() []byte {
	file_peer_proto_rawDescOnce.Do(func() {
		file_peer_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_peer_proto_rawDesc), len(file_peer_proto_rawDesc)))
	})
	return file_peer_proto_rawDescData
}

var file_peer_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_peer_proto_msgTypes = make([]protoimpl.MessageInfo, 6)
var file_peer_proto_goTypes = []any{
	(Topic)(0),                  // 0: types.Topic
	(*PeerInfo)(nil),            // 1: types.PeerInfo
	(*PeerAddress)(nil),         // 2: types.PeerAddress
	(*PeerMeta)(nil),            // 3: types.PeerMeta
	(*BlockRequestMessage)(nil), // 4: types.BlockRequestMessage
	(*BlockMessage)(nil),        // 5: types.BlockMessage
	(*TxMessage)(nil),           // 6: types.TxMessage
	(*QuorumCertificate)(nil),   // 7: types.QuorumCertificate
}
var file_peer_proto_depIdxs = []int32{
	2, // 0: types.PeerInfo.Address:type_name -> types.PeerAddress
	3, // 1: types.PeerAddress.peer_meta:type_name -> types.PeerMeta
	7, // 2: types.BlockMessage.BlockAndCertificate:type_name -> types.QuorumCertificate
	3, // [3:3] is the sub-list for method output_type
	3, // [3:3] is the sub-list for method input_type
	3, // [3:3] is the sub-list for extension type_name
	3, // [3:3] is the sub-list for extension extendee
	0, // [0:3] is the sub-list for field type_name
}

func init() { file_peer_proto_init() }
func file_peer_proto_init() {
	if File_peer_proto != nil {
		return
	}
	file_certificate_proto_init()
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_peer_proto_rawDesc), len(file_peer_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   6,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_peer_proto_goTypes,
		DependencyIndexes: file_peer_proto_depIdxs,
		EnumInfos:         file_peer_proto_enumTypes,
		MessageInfos:      file_peer_proto_msgTypes,
	}.Build()
	File_peer_proto = out.File
	file_peer_proto_goTypes = nil
	file_peer_proto_depIdxs = nil
}
