routing: update package to account for recent channeldb API changes

routing/router.go

@@ -814,7 +814,7 @@ func (r *ChannelRouter) processUpdate(msg interface{}) error {
 		// attack by node announcements, we will ignore such nodes. If
 		// we do know about this node, check that this update brings
 		// info newer than what we already have.
-		lastUpdate, exists, err := r.cfg.Graph.HasLightningNode(msg.PubKey)
+		lastUpdate, exists, err := r.cfg.Graph.HasLightningNode(msg.PubKeyBytes)
 		if err != nil {
 			return errors.Errorf("unable to query for the "+
 				"existence of node: %v", err)
@@ -822,7 +822,7 @@ func (r *ChannelRouter) processUpdate(msg interface{}) error {
 		if !exists {
 			return newErrf(ErrIgnored, "Ignoring node announcement"+
 				" for node not found in channel graph (%x)",
-				msg.PubKey.SerializeCompressed())
+				msg.PubKeyBytes)
 		}
 
 		// If we've reached this point then we're aware of the vertex
@@ -833,16 +833,15 @@ func (r *ChannelRouter) processUpdate(msg interface{}) error {
 			lastUpdate.Equal(msg.LastUpdate) {
 
 			return newErrf(ErrOutdated, "Ignoring outdated "+
-				"announcement for %x", msg.PubKey.SerializeCompressed())
+				"announcement for %x", msg.PubKeyBytes)
 		}
 
 		if err := r.cfg.Graph.AddLightningNode(msg); err != nil {
 			return errors.Errorf("unable to add node %v to the "+
-				"graph: %v", msg.PubKey.SerializeCompressed(), err)
+				"graph: %v", msg.PubKeyBytes, err)
 		}
 
-		log.Infof("Updated vertex data for node=%x",
-			msg.PubKey.SerializeCompressed())
+		log.Infof("Updated vertex data for node=%x", msg.PubKeyBytes)
 
 	case *channeldb.ChannelEdgeInfo:
 		// Prior to processing the announcement we first check if we
@@ -859,30 +858,28 @@ func (r *ChannelRouter) processUpdate(msg interface{}) error {
 		// Query the database for the existence of the two nodes in this
 		// channel. If not found, add a partial node to the database,
 		// containing only the node keys.
-		_, exists, _ = r.cfg.Graph.HasLightningNode(msg.NodeKey1)
+		_, exists, _ = r.cfg.Graph.HasLightningNode(msg.NodeKey1Bytes)
 		if !exists {
 			node1 := &channeldb.LightningNode{
-				PubKey:               msg.NodeKey1,
+				PubKeyBytes:          msg.NodeKey1Bytes,
 				HaveNodeAnnouncement: false,
 			}
 			err := r.cfg.Graph.AddLightningNode(node1)
 			if err != nil {
 				return errors.Errorf("unable to add node %v to"+
-					" the graph: %v",
-					node1.PubKey.SerializeCompressed(), err)
+					" the graph: %v", node1.PubKeyBytes, err)
 			}
 		}
-		_, exists, _ = r.cfg.Graph.HasLightningNode(msg.NodeKey2)
+		_, exists, _ = r.cfg.Graph.HasLightningNode(msg.NodeKey2Bytes)
 		if !exists {
 			node2 := &channeldb.LightningNode{
-				PubKey:               msg.NodeKey2,
+				PubKeyBytes:          msg.NodeKey2Bytes,
 				HaveNodeAnnouncement: false,
 			}
 			err := r.cfg.Graph.AddLightningNode(node2)
 			if err != nil {
 				return errors.Errorf("unable to add node %v to"+
-					" the graph: %v",
-					node2.PubKey.SerializeCompressed(), err)
+					" the graph: %v", node2.PubKeyBytes, err)
 			}
 		}
 
@@ -911,8 +908,7 @@ func (r *ChannelRouter) processUpdate(msg interface{}) error {
 		// edge bitcoin keys and channel value corresponds to the
 		// reality.
 		_, witnessOutput, err := lnwallet.GenFundingPkScript(
-			msg.BitcoinKey1.SerializeCompressed(),
-			msg.BitcoinKey2.SerializeCompressed(),
+			msg.BitcoinKey1Bytes[:], msg.BitcoinKey2Bytes[:],
 			chanUtxo.Value,
 		)
 		if err != nil {
@@ -942,8 +938,7 @@ func (r *ChannelRouter) processUpdate(msg interface{}) error {
 		log.Infof("New channel discovered! Link "+
 			"connects %x and %x with ChannelPoint(%v): "+
 			"chan_id=%v, capacity=%v",
-			msg.NodeKey1.SerializeCompressed(),
-			msg.NodeKey2.SerializeCompressed(),
+			msg.NodeKey1Bytes, msg.NodeKey2Bytes,
 			fundingPoint, msg.ChannelID, msg.Capacity)
 
 		// As a new edge has been added to the channel graph, we'll
@@ -1183,7 +1178,8 @@ func (r *ChannelRouter) FindRoutes(target *btcec.PublicKey,
 
 	// We can short circuit the routing by opportunistically checking to
 	// see if the target vertex event exists in the current graph.
-	if _, exists, err := r.cfg.Graph.HasLightningNode(target); err != nil {
+	targetVertex := NewVertex(target)
+	if _, exists, err := r.cfg.Graph.HasLightningNode(targetVertex); err != nil {
 		return nil, err
 	} else if !exists {
 		log.Debugf("Target %x is not in known graph", dest)
@@ -1221,7 +1217,7 @@ func (r *ChannelRouter) FindRoutes(target *btcec.PublicKey,
 	// aren't able to support the total satoshis flow once fees have been
 	// factored in.
 	validRoutes := make([]*Route, 0, len(shortestPaths))
-	sourceVertex := NewVertex(r.selfNode.PubKey)
+	sourceVertex := Vertex(r.selfNode.PubKeyBytes)
 	for _, path := range shortestPaths {
 		// Attempt to make the path into a route. We snip off the first
 		// hop in the path as it contains a "self-hop" that is inserted
@@ -1289,10 +1285,14 @@ func generateSphinxPacket(route *Route, paymentHash []byte) ([]byte,
 		// We create a new instance of the public key to avoid possibly
 		// mutating the curve parameters, which are unset in a higher
 		// level in order to avoid spamming the logs.
+		nodePub, err := hop.Channel.Node.PubKey()
+		if err != nil {
+			return nil, nil, err
+		}
 		pub := btcec.PublicKey{
 			Curve: btcec.S256(),
-			X:     hop.Channel.Node.PubKey.X,
-			Y:     hop.Channel.Node.PubKey.Y,
+			X:     nodePub.X,
+			Y:     nodePub.Y,
 		}
 		nodes[i] = &pub
 	}
@@ -1453,7 +1453,7 @@ func (r *ChannelRouter) SendPayment(payment *LightningPayment) ([32]byte, *Route
 		// Attempt to send this payment through the network to complete
 		// the payment. If this attempt fails, then we'll continue on
 		// to the next available route.
-		firstHop := route.Hops[0].Channel.Node.PubKey
+		firstHop := route.Hops[0].Channel.Node.PubKeyBytes
 		preImage, sendError = r.cfg.SendToSwitch(firstHop, htlcAdd,
 			circuit)
 		if sendError != nil {
@@ -1693,7 +1693,7 @@ func (r *ChannelRouter) applyChannelUpdate(msg *lnwire.ChannelUpdate) error {
 	}
 
 	err := r.UpdateEdge(&channeldb.ChannelEdgePolicy{
-		Signature:                 msg.Signature,
+		SigBytes:                  msg.Signature.ToSignatureBytes(),
 		ChannelID:                 msg.ShortChannelID.ToUint64(),
 		LastUpdate:                time.Unix(int64(msg.Timestamp), 0),
 		Flags:                     msg.Flags,