channeldb: take serialized key to fetch lightning node

This prevents inefficient key conversions in a follow up commit that
change the inner pathfinding loop.

channeldb/graph.go

@@ -20,6 +20,7 @@ import (
 	"github.com/btcsuite/btcutil"
 	"github.com/coreos/bbolt"
 	"github.com/lightningnetwork/lnd/lnwire"
+	"github.com/lightningnetwork/lnd/routing/route"
 )
 
 var (
@@ -513,7 +514,7 @@ func (c *ChannelGraph) LookupAlias(pub *btcec.PublicKey) (string, error) {
 
 // DeleteLightningNode starts a new database transaction to remove a vertex/node
 // from the database according to the node's public key.
-func (c *ChannelGraph) DeleteLightningNode(nodePub *btcec.PublicKey) error {
+func (c *ChannelGraph) DeleteLightningNode(nodePub route.Vertex) error {
 	// TODO(roasbeef): ensure dangling edges are removed...
 	return c.db.Update(func(tx *bbolt.Tx) error {
 		nodes := tx.Bucket(nodeBucket)
@@ -521,9 +522,7 @@ func (c *ChannelGraph) DeleteLightningNode(nodePub *btcec.PublicKey) error {
 			return ErrGraphNodeNotFound
 		}
 
-		return c.deleteLightningNode(
-			nodes, nodePub.SerializeCompressed(),
-		)
+		return c.deleteLightningNode(nodes, nodePub[:])
 	})
 }
 
@@ -2180,9 +2179,10 @@ func (l *LightningNode) isPublic(tx *bbolt.Tx, sourcePubKey []byte) (bool, error
 // FetchLightningNode attempts to look up a target node by its identity public
 // key. If the node isn't found in the database, then ErrGraphNodeNotFound is
 // returned.
-func (c *ChannelGraph) FetchLightningNode(pub *btcec.PublicKey) (*LightningNode, error) {
+func (c *ChannelGraph) FetchLightningNode(nodePub route.Vertex) (*LightningNode,
+	error) {
+
 	var node *LightningNode
-	nodePub := pub.SerializeCompressed()
 	err := c.db.View(func(tx *bbolt.Tx) error {
 		// First grab the nodes bucket which stores the mapping from
 		// pubKey to node information.
@@ -2193,7 +2193,7 @@ func (c *ChannelGraph) FetchLightningNode(pub *btcec.PublicKey) (*LightningNode,
 
 		// If a key for this serialized public key isn't found, then
 		// the target node doesn't exist within the database.
-		nodeBytes := nodes.Get(nodePub)
+		nodeBytes := nodes.Get(nodePub[:])
 		if nodeBytes == nil {
 			return ErrGraphNodeNotFound
 		}

channeldb/graph_test.go

@@ -20,6 +20,7 @@ import (
 	"github.com/coreos/bbolt"
 	"github.com/davecgh/go-spew/spew"
 	"github.com/lightningnetwork/lnd/lnwire"
+	"github.com/lightningnetwork/lnd/routing/route"
 )
 
 var (
@@ -37,6 +38,8 @@ var (
 	_, _ = testSig.S.SetString("18801056069249825825291287104931333862866033135609736119018462340006816851118", 10)
 
 	testFeatures = lnwire.NewFeatureVector(nil, lnwire.Features)
+
+	testPub = route.Vertex{2, 202, 4}
 )
 
 func createLightningNode(db *DB, priv *btcec.PrivateKey) (*LightningNode, error) {
@@ -80,7 +83,6 @@ func TestNodeInsertionAndDeletion(t *testing.T) {
 
 	// We'd like to test basic insertion/deletion for vertexes from the
 	// graph, so we'll create a test vertex to start with.
-	_, testPub := btcec.PrivKeyFromBytes(btcec.S256(), key[:])
 	node := &LightningNode{
 		HaveNodeAnnouncement: true,
 		AuthSigBytes:         testSig.Serialize(),
@@ -90,9 +92,9 @@ func TestNodeInsertionAndDeletion(t *testing.T) {
 		Features:             testFeatures,
 		Addresses:            testAddrs,
 		ExtraOpaqueData:      []byte("extra new data"),
+		PubKeyBytes:          testPub,
 		db:                   db,
 	}
-	copy(node.PubKeyBytes[:], testPub.SerializeCompressed())
 
 	// First, insert the node into the graph DB. This should succeed
 	// without any errors.
@@ -147,11 +149,10 @@ func TestPartialNode(t *testing.T) {
 
 	// We want to be able to insert nodes into the graph that only has the
 	// PubKey set.
-	_, testPub := btcec.PrivKeyFromBytes(btcec.S256(), key[:])
 	node := &LightningNode{
 		HaveNodeAnnouncement: false,
+		PubKeyBytes:          testPub,
 	}
-	copy(node.PubKeyBytes[:], testPub.SerializeCompressed())
 
 	if err := graph.AddLightningNode(node); err != nil {
 		t.Fatalf("unable to add node: %v", err)
@@ -175,9 +176,9 @@ func TestPartialNode(t *testing.T) {
 	node = &LightningNode{
 		HaveNodeAnnouncement: false,
 		LastUpdate:           time.Unix(0, 0),
+		PubKeyBytes:          testPub,
 		db:                   db,
 	}
-	copy(node.PubKeyBytes[:], testPub.SerializeCompressed())
 
 	if err := compareNodes(node, dbNode); err != nil {
 		t.Fatalf("nodes don't match: %v", err)
@@ -2386,11 +2387,7 @@ func TestPruneGraphNodes(t *testing.T) {
 
 	// Finally, we'll ensure that node3, the only fully unconnected node as
 	// properly deleted from the graph and not another node in its place.
-	node3Pub, err := node3.PubKey()
-	if err != nil {
-		t.Fatalf("unable to fetch the pubkey of node3: %v", err)
-	}
-	if _, err := graph.FetchLightningNode(node3Pub); err == nil {
+	if _, err := graph.FetchLightningNode(node3.PubKeyBytes); err == nil {
 		t.Fatalf("node 3 should have been deleted!")
 	}
 }
@@ -2430,18 +2427,9 @@ func TestAddChannelEdgeShellNodes(t *testing.T) {
 		t.Fatalf("unable to add edge: %v", err)
 	}
 
-	node1Pub, err := node1.PubKey()
-	if err != nil {
-		t.Fatalf("unable to parse node 1 pub: %v", err)
-	}
-	node2Pub, err := node2.PubKey()
-	if err != nil {
-		t.Fatalf("unable to parse node 2 pub: %v", err)
-	}
-
 	// Ensure that node1 was inserted as a full node, while node2 only has
 	// a shell node present.
-	node1, err = graph.FetchLightningNode(node1Pub)
+	node1, err = graph.FetchLightningNode(node1.PubKeyBytes)
 	if err != nil {
 		t.Fatalf("unable to fetch node1: %v", err)
 	}
@@ -2449,7 +2437,7 @@ func TestAddChannelEdgeShellNodes(t *testing.T) {
 		t.Fatalf("have shell announcement for node1, shouldn't")
 	}
 
-	node2, err = graph.FetchLightningNode(node2Pub)
+	node2, err = graph.FetchLightningNode(node2.PubKeyBytes)
 	if err != nil {
 		t.Fatalf("unable to fetch node2: %v", err)
 	}
@@ -2504,8 +2492,7 @@ func TestNodePruningUpdateIndexDeletion(t *testing.T) {
 
 	// We'll now delete the node from the graph, this should result in it
 	// being removed from the update index as well.
-	nodePub, _ := node1.PubKey()
-	if err := graph.DeleteLightningNode(nodePub); err != nil {
+	if err := graph.DeleteLightningNode(node1.PubKeyBytes); err != nil {
 		t.Fatalf("unable to delete node: %v", err)
 	}