diff --git a/routing/missioncontrol.go b/routing/missioncontrol.go index 7789c93f..8d8e595c 100644 --- a/routing/missioncontrol.go +++ b/routing/missioncontrol.go @@ -239,7 +239,7 @@ func (p *paymentSession) RequestRoute(payment *LightningPayment, // With the next candidate path found, we'll attempt to turn this into // a route by applying the time-lock and fee requirements. - sourceVertex := NewVertex(p.mc.selfNode.PubKey) + sourceVertex := Vertex(p.mc.selfNode.PubKeyBytes) route, err := newRoute(payment.Amount, sourceVertex, path, height, finalCltvDelta) if err != nil { diff --git a/routing/notifications.go b/routing/notifications.go index 0a1c067d..c263fc2e 100644 --- a/routing/notifications.go +++ b/routing/notifications.go @@ -296,9 +296,13 @@ func addToTopologyChange(graph *channeldb.ChannelGraph, update *TopologyChange, // Any node announcement maps directly to a NetworkNodeUpdate struct. // No further data munging or db queries are required. case *channeldb.LightningNode: + pubKey, err := m.PubKey() + if err != nil { + return err + } nodeUpdate := &NetworkNodeUpdate{ Addresses: m.Addresses, - IdentityKey: m.PubKey, + IdentityKey: pubKey, Alias: m.Alias, } nodeUpdate.IdentityKey.Curve = nil @@ -332,6 +336,15 @@ func addToTopologyChange(graph *channeldb.ChannelGraph, update *TopologyChange, connectingNode = edgeInfo.NodeKey1 } + aNode, err := sourceNode() + if err != nil { + return err + } + cNode, err := connectingNode() + if err != nil { + return err + } + edgeUpdate := &ChannelEdgeUpdate{ ChanID: m.ChannelID, ChanPoint: edgeInfo.ChannelPoint, @@ -340,8 +353,8 @@ func addToTopologyChange(graph *channeldb.ChannelGraph, update *TopologyChange, MinHTLC: m.MinHTLC, BaseFee: m.FeeBaseMSat, FeeRate: m.FeeProportionalMillionths, - AdvertisingNode: sourceNode, - ConnectingNode: connectingNode, + AdvertisingNode: aNode, + ConnectingNode: cNode, } edgeUpdate.AdvertisingNode.Curve = nil edgeUpdate.ConnectingNode.Curve = nil diff --git a/routing/notifications_test.go b/routing/notifications_test.go index 8e3c8df3..7e09514a 100644 --- a/routing/notifications_test.go +++ b/routing/notifications_test.go @@ -51,23 +51,25 @@ func createTestNode() (*channeldb.LightningNode, error) { } pub := priv.PubKey().SerializeCompressed() - return &channeldb.LightningNode{ + n := &channeldb.LightningNode{ HaveNodeAnnouncement: true, LastUpdate: time.Unix(updateTime, 0), Addresses: testAddrs, - PubKey: priv.PubKey(), Color: color.RGBA{1, 2, 3, 0}, Alias: "kek" + string(pub[:]), - AuthSig: testSig, + AuthSigBytes: testSig.Serialize(), Features: testFeatures, - }, nil + } + copy(n.PubKeyBytes[:], pub) + + return n, nil } func randEdgePolicy(chanID *lnwire.ShortChannelID, node *channeldb.LightningNode) *channeldb.ChannelEdgePolicy { return &channeldb.ChannelEdgePolicy{ - Signature: testSig, + SigBytes: testSig.Serialize(), ChannelID: chanID.ToUint64(), LastUpdate: time.Unix(int64(prand.Int31()), 0), TimeLockDelta: uint16(prand.Int63()), @@ -371,18 +373,18 @@ func TestEdgeUpdateNotification(t *testing.T) { // Finally, to conclude our test set up, we'll create a channel // update to announce the created channel between the two nodes. edge := &channeldb.ChannelEdgeInfo{ - ChannelID: chanID.ToUint64(), - NodeKey1: node1.PubKey, - NodeKey2: node2.PubKey, - BitcoinKey1: bitcoinKey1, - BitcoinKey2: bitcoinKey2, + ChannelID: chanID.ToUint64(), + NodeKey1Bytes: node1.PubKeyBytes, + NodeKey2Bytes: node2.PubKeyBytes, AuthProof: &channeldb.ChannelAuthProof{ - NodeSig1: testSig, - NodeSig2: testSig, - BitcoinSig1: testSig, - BitcoinSig2: testSig, + NodeSig1Bytes: testSig.Serialize(), + NodeSig2Bytes: testSig.Serialize(), + BitcoinSig1Bytes: testSig.Serialize(), + BitcoinSig2Bytes: testSig.Serialize(), }, } + copy(edge.BitcoinKey1Bytes[:], bitcoinKey1.SerializeCompressed()) + copy(edge.BitcoinKey2Bytes[:], bitcoinKey2.SerializeCompressed()) if err := ctx.router.AddEdge(edge); err != nil { t.Fatalf("unable to add edge: %v", err) @@ -450,8 +452,17 @@ func TestEdgeUpdateNotification(t *testing.T) { // Create lookup map for notifications we are intending to receive. Entries // are removed from the map when the anticipated notification is received. var waitingFor = map[Vertex]int{ - NewVertex(node1.PubKey): 1, - NewVertex(node2.PubKey): 2, + Vertex(node1.PubKeyBytes): 1, + Vertex(node2.PubKeyBytes): 2, + } + + node1Pub, err := node1.PubKey() + if err != nil { + t.Fatalf("unable to encode key: %v", err) + } + node2Pub, err := node2.PubKey() + if err != nil { + t.Fatalf("unable to encode key: %v", err) } const numEdgePolicies = 2 @@ -473,20 +484,20 @@ func TestEdgeUpdateNotification(t *testing.T) { case 1: // Received notification corresponding to edge1. assertEdgeCorrect(t, edgeUpdate, edge1) - if !edgeUpdate.AdvertisingNode.IsEqual(node1.PubKey) { + if !edgeUpdate.AdvertisingNode.IsEqual(node1Pub) { t.Fatal("advertising node mismatch") } - if !edgeUpdate.ConnectingNode.IsEqual(node2.PubKey) { + if !edgeUpdate.ConnectingNode.IsEqual(node2Pub) { t.Fatal("connecting node mismatch") } case 2: // Received notification corresponding to edge2. assertEdgeCorrect(t, edgeUpdate, edge2) - if !edgeUpdate.AdvertisingNode.IsEqual(node2.PubKey) { + if !edgeUpdate.AdvertisingNode.IsEqual(node2Pub) { t.Fatal("advertising node mismatch") } - if !edgeUpdate.ConnectingNode.IsEqual(node1.PubKey) { + if !edgeUpdate.ConnectingNode.IsEqual(node1Pub) { t.Fatal("connecting node mismatch") } @@ -494,8 +505,8 @@ func TestEdgeUpdateNotification(t *testing.T) { t.Fatal("invalid edge index") } - // Remove entry from waitingFor map to ensure we don't double count a - // repeat notification. + // Remove entry from waitingFor map to ensure + // we don't double count a repeat notification. delete(waitingFor, nodeVertex) } else { @@ -552,18 +563,18 @@ func TestNodeUpdateNotification(t *testing.T) { } edge := &channeldb.ChannelEdgeInfo{ - ChannelID: chanID.ToUint64(), - NodeKey1: node1.PubKey, - NodeKey2: node2.PubKey, - BitcoinKey1: bitcoinKey1, - BitcoinKey2: bitcoinKey2, + ChannelID: chanID.ToUint64(), + NodeKey1Bytes: node1.PubKeyBytes, + NodeKey2Bytes: node2.PubKeyBytes, AuthProof: &channeldb.ChannelAuthProof{ - NodeSig1: testSig, - NodeSig2: testSig, - BitcoinSig1: testSig, - BitcoinSig2: testSig, + NodeSig1Bytes: testSig.Serialize(), + NodeSig2Bytes: testSig.Serialize(), + BitcoinSig1Bytes: testSig.Serialize(), + BitcoinSig2Bytes: testSig.Serialize(), }, } + copy(edge.BitcoinKey1Bytes[:], bitcoinKey1.SerializeCompressed()) + copy(edge.BitcoinKey2Bytes[:], bitcoinKey2.SerializeCompressed()) // Adding the edge will add the nodes to the graph, but with no info // except the pubkey known. @@ -589,15 +600,17 @@ func TestNodeUpdateNotification(t *testing.T) { assertNodeNtfnCorrect := func(t *testing.T, ann *channeldb.LightningNode, nodeUpdate *NetworkNodeUpdate) { + nodeKey, _ := ann.PubKey() + // The notification received should directly map the // announcement originally sent. if nodeUpdate.Addresses[0] != ann.Addresses[0] { t.Fatalf("node address doesn't match: expected %v, got %v", nodeUpdate.Addresses[0], ann.Addresses[0]) } - if !nodeUpdate.IdentityKey.IsEqual(ann.PubKey) { + if !nodeUpdate.IdentityKey.IsEqual(nodeKey) { t.Fatalf("node identity keys don't match: expected %x, "+ - "got %x", ann.PubKey.SerializeCompressed(), + "got %x", nodeKey.SerializeCompressed(), nodeUpdate.IdentityKey.SerializeCompressed()) } if nodeUpdate.Alias != ann.Alias { @@ -609,8 +622,8 @@ func TestNodeUpdateNotification(t *testing.T) { // Create lookup map for notifications we are intending to receive. Entries // are removed from the map when the anticipated notification is received. var waitingFor = map[Vertex]int{ - NewVertex(node1.PubKey): 1, - NewVertex(node2.PubKey): 2, + Vertex(node1.PubKeyBytes): 1, + Vertex(node2.PubKeyBytes): 2, } // Exactly two notifications should be sent, each corresponding to the @@ -738,18 +751,18 @@ func TestNotificationCancellation(t *testing.T) { ntfnClient.Cancel() edge := &channeldb.ChannelEdgeInfo{ - ChannelID: chanID.ToUint64(), - NodeKey1: node1.PubKey, - NodeKey2: node2.PubKey, - BitcoinKey1: bitcoinKey1, - BitcoinKey2: bitcoinKey2, + ChannelID: chanID.ToUint64(), + NodeKey1Bytes: node1.PubKeyBytes, + NodeKey2Bytes: node2.PubKeyBytes, AuthProof: &channeldb.ChannelAuthProof{ - NodeSig1: testSig, - NodeSig2: testSig, - BitcoinSig1: testSig, - BitcoinSig2: testSig, + NodeSig1Bytes: testSig.Serialize(), + NodeSig2Bytes: testSig.Serialize(), + BitcoinSig1Bytes: testSig.Serialize(), + BitcoinSig2Bytes: testSig.Serialize(), }, } + copy(edge.BitcoinKey1Bytes[:], bitcoinKey1.SerializeCompressed()) + copy(edge.BitcoinKey2Bytes[:], bitcoinKey2.SerializeCompressed()) if err := ctx.router.AddEdge(edge); err != nil { t.Fatalf("unable to add edge: %v", err) } @@ -819,18 +832,18 @@ func TestChannelCloseNotification(t *testing.T) { // Finally, to conclude our test set up, we'll create a channel // announcement to announce the created channel between the two nodes. edge := &channeldb.ChannelEdgeInfo{ - ChannelID: chanID.ToUint64(), - NodeKey1: node1.PubKey, - NodeKey2: node2.PubKey, - BitcoinKey1: bitcoinKey1, - BitcoinKey2: bitcoinKey2, + ChannelID: chanID.ToUint64(), + NodeKey1Bytes: node1.PubKeyBytes, + NodeKey2Bytes: node2.PubKeyBytes, AuthProof: &channeldb.ChannelAuthProof{ - NodeSig1: testSig, - NodeSig2: testSig, - BitcoinSig1: testSig, - BitcoinSig2: testSig, + NodeSig1Bytes: testSig.Serialize(), + NodeSig2Bytes: testSig.Serialize(), + BitcoinSig1Bytes: testSig.Serialize(), + BitcoinSig2Bytes: testSig.Serialize(), }, } + copy(edge.BitcoinKey1Bytes[:], bitcoinKey1.SerializeCompressed()) + copy(edge.BitcoinKey2Bytes[:], bitcoinKey2.SerializeCompressed()) if err := ctx.router.AddEdge(edge); err != nil { t.Fatalf("unable to add edge: %v", err) } diff --git a/routing/pathfind.go b/routing/pathfind.go index fce5ceee..f4fdde51 100644 --- a/routing/pathfind.go +++ b/routing/pathfind.go @@ -1,6 +1,7 @@ package routing import ( + "bytes" "encoding/binary" "fmt" "math" @@ -148,7 +149,7 @@ type Route struct { // target node is not found in the route, then false is returned. func (r *Route) nextHopVertex(n *btcec.PublicKey) (Vertex, bool) { hop, ok := r.nextHopMap[NewVertex(n)] - return NewVertex(hop.Node.PubKey), ok + return Vertex(hop.Node.PubKeyBytes), ok } // nextHopChannel returns the uint64 channel ID of the next hop after the @@ -259,7 +260,7 @@ func newRoute(amtToSend lnwire.MilliSatoshi, sourceVertex Vertex, // First, we'll update both the node and channel index, to // indicate that this Vertex, and outgoing channel link are // present within this route. - v := NewVertex(edge.Node.PubKey) + v := Vertex(edge.Node.PubKeyBytes) route.nodeIndex[v] = struct{}{} route.chanIndex[edge.ChannelID] = struct{}{} @@ -314,7 +315,6 @@ func newRoute(amtToSend lnwire.MilliSatoshi, sourceVertex Vertex, AmtToForward: amtToForward, Fee: fee, } - edge.Node.PubKey.Curve = nil route.TotalFees += nextHop.Fee @@ -361,7 +361,7 @@ func newRoute(amtToSend lnwire.MilliSatoshi, sourceVertex Vertex, // We'll then make a second run through our route in order to set up // our prev hop mapping. for _, hop := range route.Hops { - vertex := NewVertex(hop.Channel.Node.PubKey) + vertex := Vertex(hop.Channel.Node.PubKeyBytes) route.prevHopMap[vertex] = hop.Channel } @@ -393,7 +393,7 @@ func (v Vertex) String() string { // directional edge with the node's ID in the opposite direction. type edgeWithPrev struct { edge *ChannelHop - prevNode *btcec.PublicKey + prevNode [33]byte } // edgeWeight computes the weight of an edge. This value is used when searching @@ -440,7 +440,7 @@ func findPath(tx *bolt.Tx, graph *channeldb.ChannelGraph, if err := graph.ForEachNode(tx, func(_ *bolt.Tx, node *channeldb.LightningNode) error { // TODO(roasbeef): with larger graph can just use disk seeks // with a visited map - distance[NewVertex(node.PubKey)] = nodeWithDist{ + distance[Vertex(node.PubKeyBytes)] = nodeWithDist{ dist: infinity, node: node, } @@ -455,7 +455,7 @@ func findPath(tx *bolt.Tx, graph *channeldb.ChannelGraph, // To start, we add the source of our path finding attempt to the // distance map with with a distance of 0. This indicates our starting // point in the graph traversal. - sourceVertex := NewVertex(sourceNode.PubKey) + sourceVertex := Vertex(sourceNode.PubKeyBytes) distance[sourceVertex] = nodeWithDist{ dist: 0, node: sourceNode, @@ -465,6 +465,8 @@ func findPath(tx *bolt.Tx, graph *channeldb.ChannelGraph, // heap. heap.Push(&nodeHeap, distance[sourceVertex]) + targetBytes := target.SerializeCompressed() + // We'll use this map as a series of "previous" hop pointers. So to get // to `Vertex` we'll take the edge that it's mapped to within `prev`. prev := make(map[Vertex]edgeWithPrev) @@ -477,19 +479,19 @@ func findPath(tx *bolt.Tx, graph *channeldb.ChannelGraph, // If we've reached our target (or we don't have any outgoing // edges), then we're done here and can exit the graph // traversal early. - if bestNode.PubKey.IsEqual(target) { + if bytes.Equal(bestNode.PubKeyBytes[:], targetBytes) { break } // Now that we've found the next potential step to take we'll // examine all the outgoing edge (channels) from this node to // further our graph traversal. - pivot := NewVertex(bestNode.PubKey) + pivot := Vertex(bestNode.PubKeyBytes) err := bestNode.ForEachChannel(tx, func(tx *bolt.Tx, edgeInfo *channeldb.ChannelEdgeInfo, outEdge, inEdge *channeldb.ChannelEdgePolicy) error { - v := NewVertex(outEdge.Node.PubKey) + v := Vertex(outEdge.Node.PubKeyBytes) // If the outgoing edge is currently disabled, then // we'll stop here, as we shouldn't attempt to route @@ -538,7 +540,7 @@ func findPath(tx *bolt.Tx, graph *channeldb.ChannelGraph, ChannelEdgePolicy: outEdge, Capacity: edgeInfo.Capacity, }, - prevNode: bestNode.PubKey, + prevNode: bestNode.PubKeyBytes, } // Add this new node to our heap as we'd like @@ -573,9 +575,8 @@ func findPath(tx *bolt.Tx, graph *channeldb.ChannelGraph, // backwards from this hop via the prev pointer for this hop // within the prevHop map. pathEdges = append(pathEdges, prev[prevNode].edge) - prev[prevNode].edge.Node.PubKey.Curve = nil - prevNode = NewVertex(prev[prevNode].prevNode) + prevNode = Vertex(prev[prevNode].prevNode) } // The route is invalid if it spans more than 20 hops. The current @@ -648,8 +649,6 @@ func findPaths(tx *bolt.Tx, graph *channeldb.ChannelGraph, shortestPaths = append(shortestPaths, firstPath) - source.PubKey.Curve = nil - // While we still have candidate paths to explore we'll keep exploring // the sub-graphs created to find the next k-th shortest path. for k := 1; k < 100; k++ { @@ -688,12 +687,12 @@ func findPaths(tx *bolt.Tx, graph *channeldb.ChannelGraph, // Next we'll remove all entries in the root path that // aren't the current spur node from the graph. for _, hop := range rootPath { - node := hop.Node.PubKey - if node.IsEqual(spurNode.PubKey) { + node := hop.Node.PubKeyBytes + if node == spurNode.PubKeyBytes { continue } - ignoredVertexes[NewVertex(node)] = struct{}{} + ignoredVertexes[Vertex(node)] = struct{}{} } // With the edges that are part of our root path, and diff --git a/routing/pathfind_test.go b/routing/pathfind_test.go index 68658686..b77c08ad 100644 --- a/routing/pathfind_test.go +++ b/routing/pathfind_test.go @@ -53,10 +53,10 @@ var ( _, _ = testSig.S.SetString("18801056069249825825291287104931333862866033135609736119018462340006816851118", 10) testAuthProof = channeldb.ChannelAuthProof{ - NodeSig1: testSig, - NodeSig2: testSig, - BitcoinSig1: testSig, - BitcoinSig2: testSig, + NodeSig1Bytes: testSig.Serialize(), + NodeSig2Bytes: testSig.Serialize(), + BitcoinSig1Bytes: testSig.Serialize(), + BitcoinSig2Bytes: testSig.Serialize(), } ) @@ -165,20 +165,16 @@ func parseTestGraph(path string) (*channeldb.ChannelGraph, func(), aliasMap, err if err != nil { return nil, nil, nil, err } - pub, err := btcec.ParsePubKey(pubBytes, btcec.S256()) - if err != nil { - return nil, nil, nil, err - } dbNode := &channeldb.LightningNode{ HaveNodeAnnouncement: true, - AuthSig: testSig, + AuthSigBytes: testSig.Serialize(), LastUpdate: time.Now(), Addresses: testAddrs, - PubKey: pub, Alias: node.Alias, Features: testFeatures, } + copy(dbNode.PubKeyBytes[:], pubBytes) // We require all aliases within the graph to be unique for our // tests. @@ -187,6 +183,11 @@ func parseTestGraph(path string) (*channeldb.ChannelGraph, func(), aliasMap, err "must be unique!") } + pub, err := btcec.ParsePubKey(pubBytes, btcec.S256()) + if err != nil { + return nil, nil, nil, err + } + // If the alias is unique, then add the node to the // alias map for easy lookup. aliasMap[node.Alias] = pub @@ -228,19 +229,11 @@ func parseTestGraph(path string) (*channeldb.ChannelGraph, func(), aliasMap, err if err != nil { return nil, nil, nil, err } - node1Pub, err := btcec.ParsePubKey(node1Bytes, btcec.S256()) - if err != nil { - return nil, nil, nil, err - } node2Bytes, err := hex.DecodeString(edge.Node2) if err != nil { return nil, nil, nil, err } - node2Pub, err := btcec.ParsePubKey(node2Bytes, btcec.S256()) - if err != nil { - return nil, nil, nil, err - } fundingTXID := strings.Split(edge.ChannelPoint, ":")[0] txidBytes, err := chainhash.NewHashFromStr(fundingTXID) @@ -256,21 +249,23 @@ func parseTestGraph(path string) (*channeldb.ChannelGraph, func(), aliasMap, err // nodes. edgeInfo := channeldb.ChannelEdgeInfo{ ChannelID: edge.ChannelID, - NodeKey1: node1Pub, - NodeKey2: node2Pub, - BitcoinKey1: node1Pub, - BitcoinKey2: node2Pub, AuthProof: &testAuthProof, ChannelPoint: fundingPoint, Capacity: btcutil.Amount(edge.Capacity), } + + copy(edgeInfo.NodeKey1Bytes[:], node1Bytes) + copy(edgeInfo.NodeKey2Bytes[:], node2Bytes) + copy(edgeInfo.BitcoinKey1Bytes[:], node1Bytes) + copy(edgeInfo.BitcoinKey2Bytes[:], node2Bytes) + err = graph.AddChannelEdge(&edgeInfo) if err != nil && err != channeldb.ErrEdgeAlreadyExist { return nil, nil, nil, err } edgePolicy := &channeldb.ChannelEdgePolicy{ - Signature: testSig, + SigBytes: testSig.Serialize(), Flags: lnwire.ChanUpdateFlag(edge.Flags), ChannelID: edge.ChannelID, LastUpdate: time.Now(), @@ -300,7 +295,7 @@ func TestBasicGraphPathFinding(t *testing.T) { if err != nil { t.Fatalf("unable to fetch source node: %v", err) } - sourceVertex := NewVertex(sourceNode.PubKey) + sourceVertex := Vertex(sourceNode.PubKeyBytes) ignoredEdges := make(map[uint64]struct{}) ignoredVertexes := make(map[Vertex]struct{}) @@ -342,13 +337,17 @@ func TestBasicGraphPathFinding(t *testing.T) { } // The first hop in the path should be an edge from roasbeef to goku. - if !route.Hops[0].Channel.Node.PubKey.IsEqual(aliases["songoku"]) { + if !bytes.Equal(route.Hops[0].Channel.Node.PubKeyBytes[:], + aliases["songoku"].SerializeCompressed()) { + t.Fatalf("first hop should be goku, is instead: %v", route.Hops[0].Channel.Node.Alias) } // The second hop should be from goku to sophon. - if !route.Hops[1].Channel.Node.PubKey.IsEqual(aliases["sophon"]) { + if !bytes.Equal(route.Hops[1].Channel.Node.PubKeyBytes[:], + aliases["sophon"].SerializeCompressed()) { + t.Fatalf("second hop should be sophon, is instead: %v", route.Hops[0].Channel.Node.Alias) } @@ -833,7 +832,7 @@ func TestPathFindSpecExample(t *testing.T) { if err != nil { t.Fatalf("unable to retrieve source node: %v", err) } - if !source.PubKey.IsEqual(alice) { + if !bytes.Equal(source.PubKeyBytes[:], alice.SerializeCompressed()) { t.Fatalf("source node not set") } diff --git a/routing/router.go b/routing/router.go index 6dc5afdf..4e92ff15 100644 --- a/routing/router.go +++ b/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, diff --git a/routing/router_test.go b/routing/router_test.go index c3b43098..48193c96 100644 --- a/routing/router_test.go +++ b/routing/router_test.go @@ -42,7 +42,7 @@ func (c *testCtx) RestartRouter() error { Graph: c.graph, Chain: c.chain, ChainView: c.chainView, - SendToSwitch: func(_ *btcec.PublicKey, + SendToSwitch: func(_ [33]byte, _ *lnwire.UpdateAddHTLC, _ *sphinx.Circuit) ([32]byte, error) { return [32]byte{}, nil }, @@ -117,8 +117,9 @@ func createTestCtx(startingHeight uint32, testGraph ...string) (*testCtx, func() Graph: graph, Chain: chain, ChainView: chainView, - SendToSwitch: func(_ *btcec.PublicKey, - _ *lnwire.UpdateAddHTLC, _ *sphinx.Circuit) ([32]byte, error) { + SendToSwitch: func(_ [33]byte, _ *lnwire.UpdateAddHTLC, + _ *sphinx.Circuit) ([32]byte, error) { + return [32]byte{}, nil }, ChannelPruneExpiry: time.Hour * 24, @@ -230,12 +231,16 @@ func TestSendPaymentRouteFailureFallback(t *testing.T) { // router's configuration to ignore the path that has luo ji as the // first hop. This should force the router to instead take the // available two hop path (through satoshi). - ctx.router.cfg.SendToSwitch = func(n *btcec.PublicKey, + ctx.router.cfg.SendToSwitch = func(n [33]byte, _ *lnwire.UpdateAddHTLC, _ *sphinx.Circuit) ([32]byte, error) { - if ctx.aliases["luoji"].IsEqual(n) { + if bytes.Equal(ctx.aliases["luoji"].SerializeCompressed(), n[:]) { + pub, err := sourceNode.PubKey() + if err != nil { + return preImage, err + } return [32]byte{}, &htlcswitch.ForwardingError{ - ErrorSource: sourceNode.PubKey, + ErrorSource: pub, // TODO(roasbeef): temp node failure should be? FailureMessage: &lnwire.FailTemporaryChannelFailure{}, } @@ -301,21 +306,26 @@ func TestSendPaymentErrorPathPruning(t *testing.T) { t.Fatalf("unable to fetch source node: %v", err) } + sourcePub, err := sourceNode.PubKey() + if err != nil { + t.Fatalf("unable to fetch source node pub: %v", err) + } + // First, we'll modify the SendToSwitch method to return an error // indicating that the channel from roasbeef to luoji is not operable // with an UnknownNextPeer. // // TODO(roasbeef): filtering should be intelligent enough so just not // go through satoshi at all at this point. - ctx.router.cfg.SendToSwitch = func(n *btcec.PublicKey, + ctx.router.cfg.SendToSwitch = func(n [33]byte, _ *lnwire.UpdateAddHTLC, _ *sphinx.Circuit) ([32]byte, error) { - if ctx.aliases["luoji"].IsEqual(n) { + if bytes.Equal(ctx.aliases["luoji"].SerializeCompressed(), n[:]) { // We'll first simulate an error from the first // outgoing link to simulate the channel from luo ji to // roasbeef not having enough capacity. return [32]byte{}, &htlcswitch.ForwardingError{ - ErrorSource: sourceNode.PubKey, + ErrorSource: sourcePub, FailureMessage: &lnwire.FailTemporaryChannelFailure{}, } } @@ -323,7 +333,7 @@ func TestSendPaymentErrorPathPruning(t *testing.T) { // Next, we'll create an error from satoshi to indicate // that the luoji node is not longer online, which should // prune out the rest of the routes. - if ctx.aliases["satoshi"].IsEqual(n) { + if bytes.Equal(ctx.aliases["satoshi"].SerializeCompressed(), n[:]) { return [32]byte{}, &htlcswitch.ForwardingError{ ErrorSource: ctx.aliases["satoshi"], FailureMessage: &lnwire.FailUnknownNextPeer{}, @@ -353,12 +363,12 @@ func TestSendPaymentErrorPathPruning(t *testing.T) { // Next, we'll modify the SendToSwitch method to indicate that luo ji // wasn't originally online. This should also halt the send all // together as all paths contain luoji and he can't be reached. - ctx.router.cfg.SendToSwitch = func(n *btcec.PublicKey, + ctx.router.cfg.SendToSwitch = func(n [33]byte, _ *lnwire.UpdateAddHTLC, _ *sphinx.Circuit) ([32]byte, error) { - if ctx.aliases["luoji"].IsEqual(n) { + if bytes.Equal(ctx.aliases["luoji"].SerializeCompressed(), n[:]) { return [32]byte{}, &htlcswitch.ForwardingError{ - ErrorSource: sourceNode.PubKey, + ErrorSource: sourcePub, FailureMessage: &lnwire.FailUnknownNextPeer{}, } } @@ -380,14 +390,14 @@ func TestSendPaymentErrorPathPruning(t *testing.T) { // Finally, we'll modify the SendToSwitch function to indicate that the // roasbeef -> luoji channel has insufficient capacity. - ctx.router.cfg.SendToSwitch = func(n *btcec.PublicKey, + ctx.router.cfg.SendToSwitch = func(n [33]byte, _ *lnwire.UpdateAddHTLC, _ *sphinx.Circuit) ([32]byte, error) { - if ctx.aliases["luoji"].IsEqual(n) { + if bytes.Equal(ctx.aliases["luoji"].SerializeCompressed(), n[:]) { // We'll first simulate an error from the first // outgoing link to simulate the channel from luo ji to // roasbeef not having enough capacity. return [32]byte{}, &htlcswitch.ForwardingError{ - ErrorSource: sourceNode.PubKey, + ErrorSource: sourcePub, FailureMessage: &lnwire.FailTemporaryChannelFailure{}, } } @@ -457,13 +467,13 @@ func TestAddProof(t *testing.T) { // After utxo was recreated adding the edge without the proof. edge := &channeldb.ChannelEdgeInfo{ - ChannelID: chanID.ToUint64(), - NodeKey1: copyPubKey(node1.PubKey), - NodeKey2: copyPubKey(node2.PubKey), - BitcoinKey1: copyPubKey(bitcoinKey1), - BitcoinKey2: copyPubKey(bitcoinKey2), - AuthProof: nil, + ChannelID: chanID.ToUint64(), + NodeKey1Bytes: node1.PubKeyBytes, + NodeKey2Bytes: node2.PubKeyBytes, + AuthProof: nil, } + copy(edge.BitcoinKey1Bytes[:], bitcoinKey1.SerializeCompressed()) + copy(edge.BitcoinKey2Bytes[:], bitcoinKey2.SerializeCompressed()) if err := ctx.router.AddEdge(edge); err != nil { t.Fatalf("unable to add edge: %v", err) @@ -495,16 +505,17 @@ func TestIgnoreNodeAnnouncement(t *testing.T) { t.Fatalf("unable to create router: %v", err) } + pub := priv1.PubKey() node := &channeldb.LightningNode{ HaveNodeAnnouncement: true, LastUpdate: time.Unix(123, 0), Addresses: testAddrs, - PubKey: copyPubKey(priv1.PubKey()), Color: color.RGBA{1, 2, 3, 0}, Alias: "node11", - AuthSig: testSig, + AuthSigBytes: testSig.Serialize(), Features: testFeatures, } + copy(node.PubKeyBytes[:], pub.SerializeCompressed()) err = ctx.router.AddNode(node) if !IsError(err, ErrIgnored) { @@ -527,15 +538,21 @@ func TestAddEdgeUnknownVertexes(t *testing.T) { t.Fatalf("unable to create router: %v", err) } + var pub1 [33]byte + copy(pub1[:], priv1.PubKey().SerializeCompressed()) + + var pub2 [33]byte + copy(pub2[:], priv2.PubKey().SerializeCompressed()) + // The two nodes we are about to add should not exist yet. - _, exists1, err := ctx.graph.HasLightningNode(priv1.PubKey()) + _, exists1, err := ctx.graph.HasLightningNode(pub1) if err != nil { t.Fatalf("unable to query graph: %v", err) } if exists1 { t.Fatalf("node already existed") } - _, exists2, err := ctx.graph.HasLightningNode(priv2.PubKey()) + _, exists2, err := ctx.graph.HasLightningNode(pub2) if err != nil { t.Fatalf("unable to query graph: %v", err) } @@ -558,12 +575,12 @@ func TestAddEdgeUnknownVertexes(t *testing.T) { ctx.chain.addBlock(fundingBlock, chanID.BlockHeight, chanID.BlockHeight) edge := &channeldb.ChannelEdgeInfo{ - ChannelID: chanID.ToUint64(), - NodeKey1: copyPubKey(priv1.PubKey()), - NodeKey2: copyPubKey(priv2.PubKey()), - BitcoinKey1: copyPubKey(bitcoinKey1), - BitcoinKey2: copyPubKey(bitcoinKey2), - AuthProof: nil, + ChannelID: chanID.ToUint64(), + NodeKey1Bytes: pub1, + NodeKey2Bytes: pub2, + BitcoinKey1Bytes: pub1, + BitcoinKey2Bytes: pub2, + AuthProof: nil, } if err := ctx.router.AddEdge(edge); err != nil { t.Fatalf("expected to be able to add edge to the channel graph,"+ @@ -573,7 +590,7 @@ func TestAddEdgeUnknownVertexes(t *testing.T) { // We must add the edge policy to be able to use the edge for route // finding. edgePolicy := &channeldb.ChannelEdgePolicy{ - Signature: testSig, + SigBytes: testSig.Serialize(), ChannelID: edge.ChannelID, LastUpdate: time.Now(), TimeLockDelta: 10, @@ -589,7 +606,7 @@ func TestAddEdgeUnknownVertexes(t *testing.T) { // Create edge in the other direction as well. edgePolicy = &channeldb.ChannelEdgePolicy{ - Signature: testSig, + SigBytes: testSig.Serialize(), ChannelID: edge.ChannelID, LastUpdate: time.Now(), TimeLockDelta: 10, @@ -605,14 +622,14 @@ func TestAddEdgeUnknownVertexes(t *testing.T) { // After adding the edge between the two previously unknown nodes, they // should have been added to the graph. - _, exists1, err = ctx.graph.HasLightningNode(priv1.PubKey()) + _, exists1, err = ctx.graph.HasLightningNode(pub1) if err != nil { t.Fatalf("unable to query graph: %v", err) } if !exists1 { t.Fatalf("node1 was not added to the graph") } - _, exists2, err = ctx.graph.HasLightningNode(priv2.PubKey()) + _, exists2, err = ctx.graph.HasLightningNode(pub2) if err != nil { t.Fatalf("unable to query graph: %v", err) } @@ -656,20 +673,20 @@ func TestAddEdgeUnknownVertexes(t *testing.T) { ctx.chain.addBlock(fundingBlock, chanID.BlockHeight, chanID.BlockHeight) edge = &channeldb.ChannelEdgeInfo{ - ChannelID: chanID.ToUint64(), - NodeKey1: pubKey1, - NodeKey2: pubKey2, - BitcoinKey1: pubKey1, - BitcoinKey2: pubKey2, - AuthProof: nil, + ChannelID: chanID.ToUint64(), + AuthProof: nil, } + copy(edge.NodeKey1Bytes[:], node1Bytes) + copy(edge.NodeKey2Bytes[:], node2Bytes) + copy(edge.BitcoinKey1Bytes[:], node1Bytes) + copy(edge.BitcoinKey2Bytes[:], node2Bytes) if err := ctx.router.AddEdge(edge); err != nil { t.Fatalf("unable to add edge to the channel graph: %v.", err) } edgePolicy = &channeldb.ChannelEdgePolicy{ - Signature: testSig, + SigBytes: testSig.Serialize(), ChannelID: edge.ChannelID, LastUpdate: time.Now(), TimeLockDelta: 10, @@ -684,7 +701,7 @@ func TestAddEdgeUnknownVertexes(t *testing.T) { } edgePolicy = &channeldb.ChannelEdgePolicy{ - Signature: testSig, + SigBytes: testSig.Serialize(), ChannelID: edge.ChannelID, LastUpdate: time.Now(), TimeLockDelta: 10, @@ -716,12 +733,12 @@ func TestAddEdgeUnknownVertexes(t *testing.T) { HaveNodeAnnouncement: true, LastUpdate: time.Unix(123, 0), Addresses: testAddrs, - PubKey: copyPubKey(priv1.PubKey()), Color: color.RGBA{1, 2, 3, 0}, Alias: "node11", - AuthSig: testSig, + AuthSigBytes: testSig.Serialize(), Features: testFeatures, } + copy(n1.PubKeyBytes[:], priv1.PubKey().SerializeCompressed()) if err := ctx.router.AddNode(n1); err != nil { t.Fatalf("could not add node: %v", err) @@ -731,12 +748,12 @@ func TestAddEdgeUnknownVertexes(t *testing.T) { HaveNodeAnnouncement: true, LastUpdate: time.Unix(123, 0), Addresses: testAddrs, - PubKey: copyPubKey(priv2.PubKey()), Color: color.RGBA{1, 2, 3, 0}, Alias: "node22", - AuthSig: testSig, + AuthSigBytes: testSig.Serialize(), Features: testFeatures, } + copy(n2.PubKeyBytes[:], priv2.PubKey().SerializeCompressed()) if err := ctx.router.AddNode(n2); err != nil { t.Fatalf("could not add node: %v", err) @@ -865,36 +882,36 @@ func TestWakeUpOnStaleBranch(t *testing.T) { } edge1 := &channeldb.ChannelEdgeInfo{ - ChannelID: chanID1, - NodeKey1: copyPubKey(node1.PubKey), - NodeKey2: copyPubKey(node2.PubKey), - BitcoinKey1: copyPubKey(bitcoinKey1), - BitcoinKey2: copyPubKey(bitcoinKey2), + ChannelID: chanID1, + NodeKey1Bytes: node1.PubKeyBytes, + NodeKey2Bytes: node2.PubKeyBytes, AuthProof: &channeldb.ChannelAuthProof{ - NodeSig1: testSig, - NodeSig2: testSig, - BitcoinSig1: testSig, - BitcoinSig2: testSig, + NodeSig1Bytes: testSig.Serialize(), + NodeSig2Bytes: testSig.Serialize(), + BitcoinSig1Bytes: testSig.Serialize(), + BitcoinSig2Bytes: testSig.Serialize(), }, } + copy(edge1.BitcoinKey1Bytes[:], bitcoinKey1.SerializeCompressed()) + copy(edge1.BitcoinKey2Bytes[:], bitcoinKey2.SerializeCompressed()) if err := ctx.router.AddEdge(edge1); err != nil { t.Fatalf("unable to add edge: %v", err) } edge2 := &channeldb.ChannelEdgeInfo{ - ChannelID: chanID2, - NodeKey1: copyPubKey(node1.PubKey), - NodeKey2: copyPubKey(node2.PubKey), - BitcoinKey1: copyPubKey(bitcoinKey1), - BitcoinKey2: copyPubKey(bitcoinKey2), + ChannelID: chanID2, + NodeKey1Bytes: node1.PubKeyBytes, + NodeKey2Bytes: node2.PubKeyBytes, AuthProof: &channeldb.ChannelAuthProof{ - NodeSig1: testSig, - NodeSig2: testSig, - BitcoinSig1: testSig, - BitcoinSig2: testSig, + NodeSig1Bytes: testSig.Serialize(), + NodeSig2Bytes: testSig.Serialize(), + BitcoinSig1Bytes: testSig.Serialize(), + BitcoinSig2Bytes: testSig.Serialize(), }, } + copy(edge2.BitcoinKey1Bytes[:], bitcoinKey1.SerializeCompressed()) + copy(edge2.BitcoinKey2Bytes[:], bitcoinKey2.SerializeCompressed()) if err := ctx.router.AddEdge(edge2); err != nil { t.Fatalf("unable to add edge: %v", err) @@ -940,7 +957,7 @@ func TestWakeUpOnStaleBranch(t *testing.T) { Graph: ctx.graph, Chain: ctx.chain, ChainView: ctx.chainView, - SendToSwitch: func(_ *btcec.PublicKey, + SendToSwitch: func(_ [33]byte, _ *lnwire.UpdateAddHTLC, _ *sphinx.Circuit) ([32]byte, error) { return [32]byte{}, nil }, @@ -1067,36 +1084,40 @@ func TestDisconnectedBlocks(t *testing.T) { } edge1 := &channeldb.ChannelEdgeInfo{ - ChannelID: chanID1, - NodeKey1: copyPubKey(node1.PubKey), - NodeKey2: copyPubKey(node2.PubKey), - BitcoinKey1: copyPubKey(bitcoinKey1), - BitcoinKey2: copyPubKey(bitcoinKey2), + ChannelID: chanID1, + NodeKey1Bytes: node1.PubKeyBytes, + NodeKey2Bytes: node2.PubKeyBytes, + BitcoinKey1Bytes: node1.PubKeyBytes, + BitcoinKey2Bytes: node2.PubKeyBytes, AuthProof: &channeldb.ChannelAuthProof{ - NodeSig1: testSig, - NodeSig2: testSig, - BitcoinSig1: testSig, - BitcoinSig2: testSig, + NodeSig1Bytes: testSig.Serialize(), + NodeSig2Bytes: testSig.Serialize(), + BitcoinSig1Bytes: testSig.Serialize(), + BitcoinSig2Bytes: testSig.Serialize(), }, } + copy(edge1.BitcoinKey1Bytes[:], bitcoinKey1.SerializeCompressed()) + copy(edge1.BitcoinKey2Bytes[:], bitcoinKey2.SerializeCompressed()) if err := ctx.router.AddEdge(edge1); err != nil { t.Fatalf("unable to add edge: %v", err) } edge2 := &channeldb.ChannelEdgeInfo{ - ChannelID: chanID2, - NodeKey1: copyPubKey(node1.PubKey), - NodeKey2: copyPubKey(node2.PubKey), - BitcoinKey1: copyPubKey(bitcoinKey1), - BitcoinKey2: copyPubKey(bitcoinKey2), + ChannelID: chanID2, + NodeKey1Bytes: node1.PubKeyBytes, + NodeKey2Bytes: node2.PubKeyBytes, + BitcoinKey1Bytes: node1.PubKeyBytes, + BitcoinKey2Bytes: node2.PubKeyBytes, AuthProof: &channeldb.ChannelAuthProof{ - NodeSig1: testSig, - NodeSig2: testSig, - BitcoinSig1: testSig, - BitcoinSig2: testSig, + NodeSig1Bytes: testSig.Serialize(), + NodeSig2Bytes: testSig.Serialize(), + BitcoinSig1Bytes: testSig.Serialize(), + BitcoinSig2Bytes: testSig.Serialize(), }, } + copy(edge2.BitcoinKey1Bytes[:], bitcoinKey1.SerializeCompressed()) + copy(edge2.BitcoinKey2Bytes[:], bitcoinKey2.SerializeCompressed()) if err := ctx.router.AddEdge(edge2); err != nil { t.Fatalf("unable to add edge: %v", err) @@ -1207,18 +1228,18 @@ func TestRouterChansClosedOfflinePruneGraph(t *testing.T) { t.Fatalf("unable to create test node: %v", err) } edge1 := &channeldb.ChannelEdgeInfo{ - ChannelID: chanID1.ToUint64(), - NodeKey1: copyPubKey(node1.PubKey), - NodeKey2: copyPubKey(node2.PubKey), - BitcoinKey1: copyPubKey(bitcoinKey1), - BitcoinKey2: copyPubKey(bitcoinKey2), + ChannelID: chanID1.ToUint64(), + NodeKey1Bytes: node1.PubKeyBytes, + NodeKey2Bytes: node2.PubKeyBytes, AuthProof: &channeldb.ChannelAuthProof{ - NodeSig1: testSig, - NodeSig2: testSig, - BitcoinSig1: testSig, - BitcoinSig2: testSig, + NodeSig1Bytes: testSig.Serialize(), + NodeSig2Bytes: testSig.Serialize(), + BitcoinSig1Bytes: testSig.Serialize(), + BitcoinSig2Bytes: testSig.Serialize(), }, } + copy(edge1.BitcoinKey1Bytes[:], bitcoinKey1.SerializeCompressed()) + copy(edge1.BitcoinKey2Bytes[:], bitcoinKey2.SerializeCompressed()) if err := ctx.router.AddEdge(edge1); err != nil { t.Fatalf("unable to add edge: %v", err) } diff --git a/routing/validation_barrier.go b/routing/validation_barrier.go index b33bb457..7878099e 100644 --- a/routing/validation_barrier.go +++ b/routing/validation_barrier.go @@ -104,8 +104,8 @@ func (v *ValidationBarrier) InitJobDependencies(job interface{}) { v.chanAnnFinSignal[msg.ShortChannelID] = annFinCond v.chanEdgeDependencies[msg.ShortChannelID] = annFinCond - v.nodeAnnDependencies[NewVertex(msg.NodeID1)] = annFinCond - v.nodeAnnDependencies[NewVertex(msg.NodeID2)] = annFinCond + v.nodeAnnDependencies[Vertex(msg.NodeID1)] = annFinCond + v.nodeAnnDependencies[Vertex(msg.NodeID2)] = annFinCond } case *channeldb.ChannelEdgeInfo: @@ -116,8 +116,8 @@ func (v *ValidationBarrier) InitJobDependencies(job interface{}) { v.chanAnnFinSignal[shortID] = annFinCond v.chanEdgeDependencies[shortID] = annFinCond - v.nodeAnnDependencies[NewVertex(msg.NodeKey1)] = annFinCond - v.nodeAnnDependencies[NewVertex(msg.NodeKey2)] = annFinCond + v.nodeAnnDependencies[Vertex(msg.NodeKey1)] = annFinCond + v.nodeAnnDependencies[Vertex(msg.NodeKey2)] = annFinCond } // These other types don't have any dependants, so no further @@ -127,6 +127,7 @@ func (v *ValidationBarrier) InitJobDependencies(job interface{}) { case *lnwire.ChannelUpdate: return case *lnwire.NodeAnnouncement: + // TODO(roasbeef): node ann needs to wait on existing channel updates return case *channeldb.LightningNode: return @@ -167,12 +168,12 @@ func (v *ValidationBarrier) WaitForDependants(job interface{}) { shortID := lnwire.NewShortChanIDFromInt(msg.ChannelID) signal, ok = v.chanEdgeDependencies[shortID] case *channeldb.LightningNode: - vertex := NewVertex(msg.PubKey) + vertex := Vertex(msg.PubKey) signal, ok = v.nodeAnnDependencies[vertex] case *lnwire.ChannelUpdate: signal, ok = v.chanEdgeDependencies[msg.ShortChannelID] case *lnwire.NodeAnnouncement: - vertex := NewVertex(msg.NodeID) + vertex := Vertex(msg.NodeID) signal, ok = v.nodeAnnDependencies[vertex] // Other types of jobs can be executed immediately, so we'll just @@ -233,9 +234,9 @@ func (v *ValidationBarrier) SignalDependants(job interface{}) { // map, as if we reach this point, then all dependants have already // finished executing and we can proceed. case *channeldb.LightningNode: - delete(v.nodeAnnDependencies, NewVertex(msg.PubKey)) + delete(v.nodeAnnDependencies, Vertex(msg.PubKey)) case *lnwire.NodeAnnouncement: - delete(v.nodeAnnDependencies, NewVertex(msg.NodeID)) + delete(v.nodeAnnDependencies, Vertex(msg.NodeID)) case *lnwire.ChannelUpdate: delete(v.chanEdgeDependencies, msg.ShortChannelID) case *channeldb.ChannelEdgePolicy: