channeldb: add persist nodeannounment config in db

channeldb/db.go

@@ -447,6 +447,7 @@ var dbTopLevelBuckets = [][]byte{
  outpointBucket,
  chanIDBucket,
  historicalChannelBucket,
+ nodeAnnouncementBucket,
 }
 
 // Wipe completely deletes all saved state within all used buckets within the

channeldb/error.go

@@ -108,6 +108,16 @@ var (
  // channel with a channel point that is already present in the
  // database.
  ErrChanAlreadyExists = fmt.Errorf("channel already exists")
+
+ // ErrNodeAnnBucketNotFound is returned when the nodeannouncement
+ // bucket hasn't been created yet.
+ ErrNodeAnnBucketNotFound = fmt.Errorf("no node announcement bucket " +
+ "exist")
+
+ // ErrNodeAnnNotFound is returned when we're unable to find the target
+ // node announcement.
+ ErrNodeAnnNotFound = fmt.Errorf("node announcement with target " +
+ "identity not found")
 )
 
 // ErrTooManyExtraOpaqueBytes creates an error which should be returned if the

channeldb/node.go

@@ -0,0 +1,222 @@
+package channeldb
+
+import (
+ "bytes"
+ "image/color"
+ "io"
+ "net"
+
+ "github.com/btcsuite/btcd/btcec/v2"
+ "github.com/lightningnetwork/lnd/kvdb"
+ "github.com/lightningnetwork/lnd/lnwire"
+)
+
+var (
+ // nodeAnnouncementBucket stores announcement config pertaining to node.
+ // This bucket allows one to query for persisted node announcement
+ // config and use it when starting orrestarting a node
+ nodeAnnouncementBucket = []byte("nab")
+)
+
+// NodeAlias is a hex encoded UTF-8 string that may be displayed as an
+// alternative to the node's ID. Notice that aliases are not unique and may be
+// freely chosen by the node operators.
+type NodeAlias [32]byte
+
+// String returns a utf8 string representation of the alias bytes.
+func (n NodeAlias) String() string {
+ // Trim trailing zero-bytes for presentation
+ return string(bytes.Trim(n[:], "\x00"))
+}
+
+type NodeAnnouncement struct {
+ // Alias is used to customize node's appearance in maps and
+ // graphs
+ Alias NodeAlias
+
+ // Color represent the hexadecimal value that node operators can assign
+ // to their nodes. It's represented as a hex string.
+ Color color.RGBA
+
+ // NodeID is a public key which is used as node identification.
+ NodeID [33]byte
+
+ // Address includes two specification fields: 'ipv6' and 'port' on
+ // which the node is accepting incoming connections.
+ Addresses []net.Addr
+
+ // Features is the list of protocol features this node supports.
+ Features *lnwire.RawFeatureVector
+}
+
+// Sync performs a full database sync which writes the current up-to-date data
+// within the struct to the database.
+func (n *NodeAnnouncement) Sync(db *DB) error {
+ return kvdb.Update(db, func(tx kvdb.RwTx) error {
+ nodeAnnBucket := tx.ReadWriteBucket(nodeAnnouncementBucket)
+ if nodeAnnBucket == nil {
+ return ErrNodeAnnBucketNotFound
+ }
+
+ return putNodeAnnouncement(nodeAnnBucket, n)
+ }, func() {})
+}
+
+// FetchNodeAnnouncement attempts to lookup the data for NodeAnnouncement based
+// on a target identity public key. If a particular NodeAnnouncement for the
+// passed identity public key cannot be found, then returns ErrNodeAnnNotFound
+func (d *DB) FetchNodeAnnouncement(identity *btcec.PublicKey) (*NodeAnnouncement, error) {
+ var nodeAnnouncement *NodeAnnouncement
+
+ err := kvdb.View(d, func(tx kvdb.RTx) error {
+ nodeAnn, err := fetchNodeAnnouncement(tx, identity)
+ if err != nil {
+ return err
+ }
+
+ nodeAnnouncement = nodeAnn
+ return nil
+ }, func() {
+ nodeAnnouncement = nil
+ })
+
+ return nodeAnnouncement, err
+}
+
+func fetchNodeAnnouncement(tx kvdb.RTx, targetPub *btcec.PublicKey) (*NodeAnnouncement, error) {
+ // First fetch the bucket for storing node announcement, bailing out
+ // early if it hasn't been created yet.
+ nodeAnnBucket := tx.ReadBucket(nodeAnnouncementBucket)
+ if nodeAnnBucket == nil {
+ return nil, ErrNodeAnnBucketNotFound
+ }
+
+ // If a node announcement for that particular public key cannot be
+ // located, then exit early with ErrNodeAnnNotFound
+ pubkey := targetPub.SerializeCompressed()
+ nodeAnnBytes := nodeAnnBucket.Get(pubkey)
+ if nodeAnnBytes == nil {
+ return nil, ErrNodeAnnNotFound
+ }
+
+ // FInally, decode and allocate a fresh NodeAnnouncement object to be
+ // returned to the caller
+ nodeAnnReader := bytes.NewReader(nodeAnnBytes)
+ return deserializeNodeAnnouncement(nodeAnnReader)
+
+}
+
+func (d *DB) PutNodeAnnouncement(pubkey [33]byte, alias [32]byte, color color.RGBA,
+ addresses []net.Addr, features *lnwire.RawFeatureVector) error {
+ nodeAnn := &NodeAnnouncement{
+ Alias: alias,
+ Color: color,
+ NodeID: pubkey,
+ Addresses: addresses,
+ Features: features,
+ }
+
+ return kvdb.Update(d, func(tx kvdb.RwTx) error {
+ nodeAnnBucket := tx.ReadWriteBucket(nodeAnnouncementBucket)
+ if nodeAnnBucket == nil {
+ return ErrNodeAnnBucketNotFound
+ }
+
+ return putNodeAnnouncement(nodeAnnBucket, nodeAnn)
+
+ }, func() {})
+}
+
+func putNodeAnnouncement(nodeAnnBucket kvdb.RwBucket, n *NodeAnnouncement) error {
+ var b bytes.Buffer
+ if err := serializeNodeAnnouncement(&b, n); err != nil {
+ return err
+ }
+
+ nodePub := n.NodeID[:]
+ return nodeAnnBucket.Put(nodePub, b.Bytes())
+}
+
+func serializeNodeAnnouncement(w io.Writer, n *NodeAnnouncement) error {
+ // Serialize Alias
+ if _, err := w.Write([]byte(n.Alias[:])); err != nil {
+ return err
+ }
+
+ // Serialize Color
+ // Write R
+ if _, err := w.Write([]byte{n.Color.R}); err != nil {
+ return err
+ }
+ // Write G
+ if _, err := w.Write([]byte{n.Color.G}); err != nil {
+ return err
+ }
+ // Write B
+ if _, err := w.Write([]byte{n.Color.B}); err != nil {
+ return err
+ }
+
+ // Serialize NodeID
+ if _, err := w.Write(n.NodeID[:]); err != nil {
+ return err
+ }
+
+ // Serialize Addresses
+ var addrBuffer bytes.Buffer
+ if err := lnwire.WriteNetAddrs(&addrBuffer, n.Addresses); err != nil {
+ return err
+ }
+ if _, err := w.Write(addrBuffer.Bytes()); err != nil {
+ return err
+ }
+
+ // Serialize Features
+ var featsBuffer bytes.Buffer
+ if err := lnwire.WriteRawFeatureVector(&featsBuffer, n.Features); err != nil {
+ return err
+ }
+ if _, err := w.Write(featsBuffer.Bytes()); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func deserializeNodeAnnouncement(r io.Reader) (*NodeAnnouncement, error) {
+ var err error
+ nodeAnn := &NodeAnnouncement{}
+
+ // Read Alias
+ aliasBuf := make([]byte, 32)
+ if _, err := io.ReadFull(r, aliasBuf); err != nil {
+ return nil, err
+ }
+ nodeAnn.Alias = [32]byte(aliasBuf)
+
+ // Read Color
+ // colorBuf contains R, G, B, A (alpha), but the color.RGBA type only
+ // expects R, G, B, so we need to slice it.
+ colorBuf := make([]byte, 3)
+ if _, err := io.ReadFull(r, colorBuf); err != nil {
+ return nil, err
+ }
+ nodeAnn.Color = color.RGBA{colorBuf[0], colorBuf[1], colorBuf[2], 0}
+
+ var pub [33]byte
+ if _, err := io.ReadFull(r, pub[:]); err != nil {
+ return nil, err
+ }
+ nodeAnn.NodeID = pub
+
+ if err := lnwire.ReadElement(r, &nodeAnn.Addresses); err != nil {
+ return nil, err
+ }
+
+ if err := lnwire.ReadElement(r, &nodeAnn.Features); err != nil {
+ return nil, err
+ }
+
+ return nodeAnn, err
+
+}

channeldb/node_test.go

@@ -0,0 +1,65 @@
+package channeldb
+
+import (
+ "image/color"
+ "net"
+ "reflect"
+ "testing"
+
+ "github.com/btcsuite/btcd/btcec/v2"
+ "github.com/lightningnetwork/lnd/lnwire"
+ "github.com/stretchr/testify/require"
+)
+
+func TestNodeAnnouncementEncodeDecode(t *testing.T) {
+ t.Parallel()
+
+ fullDB, err := MakeTestDB(t)
+ require.NoError(t, err, "unable to make test database")
+
+ // We'll start by creating initial data to use for populating our test
+ // node announcement instance
+ var alias [32]byte
+ copy(alias[:], []byte("alice"))
+ color := color.RGBA{255, 255, 255, 0}
+ _, pub := btcec.PrivKeyFromBytes(key[:])
+ address := []net.Addr{testAddr}
+ features := lnwire.RawFeatureVector{}
+
+ nodeAnn := &NodeAnnouncement{
+ Alias: alias,
+ Color: color,
+ NodeID: [33]byte(pub.SerializeCompressed()),
+ Addresses: address,
+ Features: &features,
+ }
+ if err := nodeAnn.Sync(fullDB); err != nil {
+ t.Fatalf("unable to sync node announcement: %v", err)
+ }
+
+ // Fetch the current node announcement from the database, it should
+ // match the one we just persisted
+ persistedNodeAnn, err := fullDB.FetchNodeAnnouncement(pub)
+ require.NoError(t, err, "unable to fetch node announcement")
+ if nodeAnn.Alias != persistedNodeAnn.Alias {
+ t.Fatalf("node aliases don't match: expected %v, got %v",
+ nodeAnn.Alias.String(), persistedNodeAnn.Alias.String())
+ }
+
+ if nodeAnn.Color != persistedNodeAnn.Color {
+ t.Fatalf("node colors don't match: expected %v, got %v",
+ nodeAnn.Color, persistedNodeAnn.Color)
+ }
+
+ if nodeAnn.NodeID != persistedNodeAnn.NodeID {
+ t.Fatalf("node nodeIds don't match: expected %v, got %v",
+ nodeAnn.NodeID, persistedNodeAnn.NodeID)
+ }
+
+ // Verify that the addresses of the node announcements are the same.
+ if !reflect.DeepEqual(nodeAnn.Addresses, persistedNodeAnn.Addresses) {
+ t.Fatalf("node addresses don't match: expected %v, got %v",
+ nodeAnn.Addresses, persistedNodeAnn.Addresses)
+ }
+
+}

lnrpc/peersrpc/config_active.go

@@ -6,6 +6,7 @@ package peersrpc
 import (
  "net"
 
+ "github.com/lightningnetwork/lnd/channeldb"
  "github.com/lightningnetwork/lnd/lnwire"
  "github.com/lightningnetwork/lnd/netann"
 )
@@ -29,4 +30,6 @@ type Config struct {
  // vector should be provided.
  UpdateNodeAnnouncement func(features *lnwire.RawFeatureVector,
  mods ...netann.NodeAnnModifier) error
+
+ ChanStateDB *channeldb.ChannelStateDB
 }

lnrpc/peersrpc/peers_server.go

@@ -398,5 +398,10 @@ func (s *Server) UpdateNodeAnnouncement(_ context.Context,
  return nil, err
  }
 
+ nodeAnnouncement := s.cfg.GetNodeAnnouncement()
+ s.cfg.ChanStateDB.GetParentDB().PutNodeAnnouncement(
+ nodeAnnouncement.NodeID, nodeAnnouncement.Alias,
+ nodeAnnouncement.RGBColor, nodeAnnouncement.Addresses, nodeAnnouncement.Features)
+
  return resp, nil
 }