graph/db/models: add node announcement serialization and address helpers

Add ToNodeAnnouncement which serializes a Node model back to its
version-appropriate lnwire.NodeAnnouncement wire message. This
enables round-tripping between the internal model and wire format.

Also add V2NodeAddrs/SetV2NodeAddrs helpers for extracting and
setting the typed address fields on v2 node announcements, and
comprehensive tests for node wire round-tripping.

Author: ellemouton

graph/db/models/node.go

@@ -10,6 +10,8 @@ import (
 	"github.com/lightningnetwork/lnd/fn/v2"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/routing/route"
+	"github.com/lightningnetwork/lnd/tlv"
+	"github.com/lightningnetwork/lnd/tor"
 )
 
 // Node represents an individual vertex/node within the channel graph.
@@ -22,6 +24,7 @@ type Node struct {
 
 	// PubKeyBytes is the raw bytes of the public key of the target node.
 	PubKeyBytes [33]byte
+	pubKey      *btcec.PublicKey
 
 	// LastUpdate is the last time the vertex information for this node has
 	// been updated.
@@ -185,20 +188,51 @@ func (n *Node) HaveAnnouncement() bool {
 
 // PubKey is the node's long-term identity public key. This key will be used to
 // authenticated any advertisements/updates sent by the node.
+//
+// NOTE: By having this method to access the attribute, we ensure we only need
+// to fully deserialize the pubkey if absolutely necessary.
 func (n *Node) PubKey() (*btcec.PublicKey, error) {
-	return btcec.ParsePubKey(n.PubKeyBytes[:])
+	if n.pubKey != nil {
+		return n.pubKey, nil
+	}
+
+	key, err := btcec.ParsePubKey(n.PubKeyBytes[:])
+	if err != nil {
+		return nil, err
+	}
+	n.pubKey = key
+
+	return key, nil
 }
 
-// NodeAnnouncement retrieves the latest node announcement of the node.
-func (n *Node) NodeAnnouncement(signed bool) (*lnwire.NodeAnnouncement1,
+// NodeAnnouncement reconstructs the wire node announcement for this node.
+// If signed is true, the returned announcement will include the node's
+// signature. Returns an error if signed is true but no signature is stored.
+func (n *Node) NodeAnnouncement(signed bool) (lnwire.NodeAnnouncement,
 	error) {
 
-	// Error out if we request the signed announcement, but we don't have
-	// a signature for this announcement.
-	if !n.HaveAnnouncement() && signed {
+	if signed && !n.HaveAnnouncement() {
 		return nil, fmt.Errorf("node does not have node announcement")
 	}
 
+	switch n.Version {
+	case lnwire.GossipVersion1:
+		return n.toNodeAnnouncement1(signed)
+
+	case lnwire.GossipVersion2:
+		return n.toNodeAnnouncement2(signed)
+
+	default:
+		return nil, fmt.Errorf("unsupported node version: %d",
+			n.Version)
+	}
+}
+
+// toNodeAnnouncement1 constructs a v1 node announcement from the node's
+// stored fields.
+func (n *Node) toNodeAnnouncement1(signed bool) (*lnwire.NodeAnnouncement1,
+	error) {
+
 	alias, err := lnwire.NewNodeAlias(n.Alias.UnwrapOr(""))
 	if err != nil {
 		return nil, err
@@ -218,12 +252,97 @@ func (n *Node) NodeAnnouncement(signed bool) (*lnwire.NodeAnnouncement1,
 		return nodeAnn, nil
 	}
 
-	sig, err := lnwire.NewSigFromECDSARawSignature(n.AuthSigBytes)
+	nodeAnn.Signature, err = lnwire.NewSigFromECDSARawSignature(
+		n.AuthSigBytes,
+	)
 	if err != nil {
 		return nil, err
 	}
 
-	nodeAnn.Signature = sig
+	return nodeAnn, nil
+}
+
+// toNodeAnnouncement2 constructs a v2 node announcement from the node's
+// stored fields.
+func (n *Node) toNodeAnnouncement2(signed bool) (*lnwire.NodeAnnouncement2,
+	error) {
+
+	nodeAnn := &lnwire.NodeAnnouncement2{
+		Features: tlv.NewRecordT[tlv.TlvType0](
+			*n.Features.RawFeatureVector,
+		),
+		BlockHeight: tlv.NewPrimitiveRecord[tlv.TlvType2](
+			n.LastBlockHeight,
+		),
+		NodeID: tlv.NewPrimitiveRecord[tlv.TlvType4, [33]byte](
+			n.PubKeyBytes,
+		),
+		ExtraSignedFields: n.ExtraSignedFields,
+	}
+
+	n.Alias.WhenSome(func(s string) {
+		aliasRecord := tlv.ZeroRecordT[tlv.TlvType3, lnwire.NodeAlias2]()
+		aliasRecord.Val = lnwire.NodeAlias2(s)
+		nodeAnn.Alias = tlv.SomeRecordT(aliasRecord)
+	})
+
+	n.Color.WhenSome(func(rgba color.RGBA) {
+		colorRecord := tlv.ZeroRecordT[tlv.TlvType1, lnwire.Color]()
+		colorRecord.Val = lnwire.Color(rgba)
+		nodeAnn.Color = tlv.SomeRecordT(colorRecord)
+	})
+
+	// Categorise addresses by type for the separate TLV fields.
+	var (
+		ipv4  lnwire.IPV4Addrs
+		ipv6  lnwire.IPV6Addrs
+		torV3 lnwire.TorV3Addrs
+	)
+	for _, addr := range n.Addresses {
+		switch a := addr.(type) {
+		case *net.TCPAddr:
+			if a.IP.To4() != nil {
+				ipv4 = append(ipv4, a)
+			} else {
+				ipv6 = append(ipv6, a)
+			}
+
+		case *tor.OnionAddr:
+			torV3 = append(torV3, a)
+
+		case *lnwire.DNSAddress:
+			nodeAnn.DNSHostName = tlv.SomeRecordT(
+				tlv.NewRecordT[tlv.TlvType11](*a),
+			)
+		}
+	}
+	if len(ipv4) > 0 {
+		nodeAnn.IPV4Addrs = tlv.SomeRecordT(
+			tlv.NewRecordT[tlv.TlvType5](ipv4),
+		)
+	}
+	if len(ipv6) > 0 {
+		nodeAnn.IPV6Addrs = tlv.SomeRecordT(
+			tlv.NewRecordT[tlv.TlvType7](ipv6),
+		)
+	}
+	if len(torV3) > 0 {
+		nodeAnn.TorV3Addrs = tlv.SomeRecordT(
+			tlv.NewRecordT[tlv.TlvType9](torV3),
+		)
+	}
+
+	if !signed {
+		return nodeAnn, nil
+	}
+
+	var err error
+	nodeAnn.Signature.Val, err = lnwire.NewSigFromSchnorrRawSignature(
+		n.AuthSigBytes,
+	)
+	if err != nil {
+		return nil, err
+	}
 
 	return nodeAnn, nil
 }