discovery: update graph API usage to match recent API changes

discovery/gossiper_test.go

@@ -305,10 +305,6 @@ func createAnnouncements(blockHeight uint32) (*annBatch, error) {
 	if err != nil {
 		return nil, err
 	}
-	batch.localChanAnn.BitcoinSig1 = nil
-	batch.localChanAnn.BitcoinSig2 = nil
-	batch.localChanAnn.NodeSig1 = nil
-	batch.localChanAnn.NodeSig2 = nil
 
 	batch.chanUpdAnn1, err = createUpdateAnnouncement(
 		blockHeight, 0, nodeKeyPriv1, timestamp,
@@ -342,13 +338,18 @@ func createNodeAnnouncement(priv *btcec.PrivateKey,
 	a := &lnwire.NodeAnnouncement{
 		Timestamp: timestamp,
 		Addresses: testAddrs,
-		NodeID:    priv.PubKey(),
 		Alias:     alias,
 		Features:  testFeatures,
 	}
+	copy(a.NodeID[:], priv.PubKey().SerializeCompressed())
 
 	signer := mockSigner{priv}
-	a.Signature, err = SignAnnouncement(&signer, priv.PubKey(), a)
+	sig, err := SignAnnouncement(&signer, priv.PubKey(), a)
+	if err != nil {
+		return nil, err
+	}
+
+	a.Signature, err = lnwire.NewSigFromSignature(sig)
 	if err != nil {
 		return nil, err
 	}
@@ -376,7 +377,13 @@ func createUpdateAnnouncement(blockHeight uint32, flags lnwire.ChanUpdateFlag,
 
 	pub := nodeKey.PubKey()
 	signer := mockSigner{nodeKey}
-	if a.Signature, err = SignAnnouncement(&signer, pub, a); err != nil {
+	sig, err := SignAnnouncement(&signer, pub, a)
+	if err != nil {
+		return nil, err
+	}
+
+	a.Signature, err = lnwire.NewSigFromSignature(sig)
+	if err != nil {
 		return nil, err
 	}
 
@@ -392,34 +399,54 @@ func createRemoteChannelAnnouncement(blockHeight uint32) (*lnwire.ChannelAnnounc
 			TxIndex:     0,
 			TxPosition:  0,
 		},
-		NodeID1:     nodeKeyPub1,
-		NodeID2:     nodeKeyPub2,
-		BitcoinKey1: bitcoinKeyPub1,
-		BitcoinKey2: bitcoinKeyPub2,
-		Features:    testFeatures,
+		Features: testFeatures,
 	}
+	copy(a.NodeID1[:], nodeKeyPub1.SerializeCompressed())
+	copy(a.NodeID2[:], nodeKeyPub2.SerializeCompressed())
+	copy(a.BitcoinKey1[:], bitcoinKeyPub1.SerializeCompressed())
+	copy(a.BitcoinKey2[:], bitcoinKeyPub2.SerializeCompressed())
 
 	pub := nodeKeyPriv1.PubKey()
 	signer := mockSigner{nodeKeyPriv1}
-	if a.NodeSig1, err = SignAnnouncement(&signer, pub, a); err != nil {
+	sig, err := SignAnnouncement(&signer, pub, a)
+	if err != nil {
+		return nil, err
+	}
+	a.NodeSig1, err = lnwire.NewSigFromSignature(sig)
+	if err != nil {
 		return nil, err
 	}
 
 	pub = nodeKeyPriv2.PubKey()
 	signer = mockSigner{nodeKeyPriv2}
-	if a.NodeSig2, err = SignAnnouncement(&signer, pub, a); err != nil {
+	sig, err = SignAnnouncement(&signer, pub, a)
+	if err != nil {
+		return nil, err
+	}
+	a.NodeSig2, err = lnwire.NewSigFromSignature(sig)
+	if err != nil {
 		return nil, err
 	}
 
 	pub = bitcoinKeyPriv1.PubKey()
 	signer = mockSigner{bitcoinKeyPriv1}
-	if a.BitcoinSig1, err = SignAnnouncement(&signer, pub, a); err != nil {
+	sig, err = SignAnnouncement(&signer, pub, a)
+	if err != nil {
+		return nil, err
+	}
+	a.BitcoinSig1, err = lnwire.NewSigFromSignature(sig)
+	if err != nil {
 		return nil, err
 	}
 
 	pub = bitcoinKeyPriv2.PubKey()
 	signer = mockSigner{bitcoinKeyPriv2}
-	if a.BitcoinSig2, err = SignAnnouncement(&signer, pub, a); err != nil {
+	sig, err = SignAnnouncement(&signer, pub, a)
+	if err != nil {
+		return nil, err
+	}
+	a.BitcoinSig2, err = lnwire.NewSigFromSignature(sig)
+	if err != nil {
 		return nil, err
 	}
 
@@ -521,8 +548,10 @@ func TestProcessAnnouncement(t *testing.T) {
 		t.Fatalf("can't create node announcement: %v", err)
 	}
 
+	nodePub := nodeKeyPriv1.PubKey()
+
 	select {
-	case err = <-ctx.gossiper.ProcessRemoteAnnouncement(na, na.NodeID):
+	case err = <-ctx.gossiper.ProcessRemoteAnnouncement(na, nodePub):
 	case <-time.After(2 * time.Second):
 		t.Fatal("remote announcement not processed")
 	}
@@ -532,7 +561,7 @@ func TestProcessAnnouncement(t *testing.T) {
 
 	select {
 	case msg := <-ctx.broadcastedMessage:
-		assertSenderExistence(na.NodeID, msg)
+		assertSenderExistence(nodePub, msg)
 	case <-time.After(2 * trickleDelay):
 		t.Fatal("announcement wasn't proceeded")
 	}
@@ -550,7 +579,7 @@ func TestProcessAnnouncement(t *testing.T) {
 	}
 
 	select {
-	case err = <-ctx.gossiper.ProcessRemoteAnnouncement(ca, na.NodeID):
+	case err = <-ctx.gossiper.ProcessRemoteAnnouncement(ca, nodePub):
 	case <-time.After(2 * time.Second):
 		t.Fatal("remote announcement not processed")
 	}
@@ -560,7 +589,7 @@ func TestProcessAnnouncement(t *testing.T) {
 
 	select {
 	case msg := <-ctx.broadcastedMessage:
-		assertSenderExistence(na.NodeID, msg)
+		assertSenderExistence(nodePub, msg)
 	case <-time.After(2 * trickleDelay):
 		t.Fatal("announcement wasn't proceeded")
 	}
@@ -578,7 +607,7 @@ func TestProcessAnnouncement(t *testing.T) {
 	}
 
 	select {
-	case err = <-ctx.gossiper.ProcessRemoteAnnouncement(ua, na.NodeID):
+	case err = <-ctx.gossiper.ProcessRemoteAnnouncement(ua, nodePub):
 	case <-time.After(2 * time.Second):
 		t.Fatal("remote announcement not processed")
 	}
@@ -588,7 +617,7 @@ func TestProcessAnnouncement(t *testing.T) {
 
 	select {
 	case msg := <-ctx.broadcastedMessage:
-		assertSenderExistence(na.NodeID, msg)
+		assertSenderExistence(nodePub, msg)
 	case <-time.After(2 * trickleDelay):
 		t.Fatal("announcement wasn't proceeded")
 	}
@@ -612,11 +641,13 @@ func TestPrematureAnnouncement(t *testing.T) {
 	}
 	defer cleanup()
 
-	na, err := createNodeAnnouncement(nodeKeyPriv1, timestamp)
+	_, err = createNodeAnnouncement(nodeKeyPriv1, timestamp)
 	if err != nil {
 		t.Fatalf("can't create node announcement: %v", err)
 	}
 
+	nodePub := nodeKeyPriv1.PubKey()
+
 	// Pretending that we receive the valid channel announcement from
 	// remote side, but block height of this announcement is greater than
 	// highest know to us, for that reason it should be added to the
@@ -627,7 +658,7 @@ func TestPrematureAnnouncement(t *testing.T) {
 	}
 
 	select {
-	case <-ctx.gossiper.ProcessRemoteAnnouncement(ca, na.NodeID):
+	case <-ctx.gossiper.ProcessRemoteAnnouncement(ca, nodePub):
 		t.Fatal("announcement was proceeded")
 	case <-time.After(100 * time.Millisecond):
 	}
@@ -646,7 +677,7 @@ func TestPrematureAnnouncement(t *testing.T) {
 	}
 
 	select {
-	case <-ctx.gossiper.ProcessRemoteAnnouncement(ua, na.NodeID):
+	case <-ctx.gossiper.ProcessRemoteAnnouncement(ua, nodePub):
 		t.Fatal("announcement was proceeded")
 	case <-time.After(100 * time.Millisecond):
 	}
@@ -709,8 +740,14 @@ func TestSignatureAnnouncementLocalFirst(t *testing.T) {
 		t.Fatalf("can't generate announcements: %v", err)
 	}
 
-	localKey := batch.nodeAnn1.NodeID
-	remoteKey := batch.nodeAnn2.NodeID
+	localKey, err := btcec.ParsePubKey(batch.nodeAnn1.NodeID[:], btcec.S256())
+	if err != nil {
+		t.Fatalf("unable to parse pubkey: %v", err)
+	}
+	remoteKey, err := btcec.ParsePubKey(batch.nodeAnn2.NodeID[:], btcec.S256())
+	if err != nil {
+		t.Fatalf("unable to parse pubkey: %v", err)
+	}
 
 	// Recreate lightning network topology. Initialize router with channel
 	// between two nodes.
@@ -865,8 +902,14 @@ func TestOrphanSignatureAnnouncement(t *testing.T) {
 		t.Fatalf("can't generate announcements: %v", err)
 	}
 
-	localKey := batch.nodeAnn1.NodeID
-	remoteKey := batch.nodeAnn2.NodeID
+	localKey, err := btcec.ParsePubKey(batch.nodeAnn1.NodeID[:], btcec.S256())
+	if err != nil {
+		t.Fatalf("unable to parse pubkey: %v", err)
+	}
+	remoteKey, err := btcec.ParsePubKey(batch.nodeAnn2.NodeID[:], btcec.S256())
+	if err != nil {
+		t.Fatalf("unable to parse pubkey: %v", err)
+	}
 
 	// Pretending that we receive local channel announcement from funding
 	// manager, thereby kick off the announcement exchange process, in
@@ -1021,8 +1064,14 @@ func TestSignatureAnnouncementRetry(t *testing.T) {
 		t.Fatalf("can't generate announcements: %v", err)
 	}
 
-	localKey := batch.nodeAnn1.NodeID
-	remoteKey := batch.nodeAnn2.NodeID
+	localKey, err := btcec.ParsePubKey(batch.nodeAnn1.NodeID[:], btcec.S256())
+	if err != nil {
+		t.Fatalf("unable to parse pubkey: %v", err)
+	}
+	remoteKey, err := btcec.ParsePubKey(batch.nodeAnn2.NodeID[:], btcec.S256())
+	if err != nil {
+		t.Fatalf("unable to parse pubkey: %v", err)
+	}
 
 	// Recreate lightning network topology. Initialize router with channel
 	// between two nodes.
@@ -1203,8 +1252,14 @@ func TestSignatureAnnouncementRetryAtStartup(t *testing.T) {
 		t.Fatalf("can't generate announcements: %v", err)
 	}
 
-	localKey := batch.nodeAnn1.NodeID
-	remoteKey := batch.nodeAnn2.NodeID
+	localKey, err := btcec.ParsePubKey(batch.nodeAnn1.NodeID[:], btcec.S256())
+	if err != nil {
+		t.Fatalf("unable to parse pubkey: %v", err)
+	}
+	remoteKey, err := btcec.ParsePubKey(batch.nodeAnn2.NodeID[:], btcec.S256())
+	if err != nil {
+		t.Fatalf("unable to parse pubkey: %v", err)
+	}
 
 	// Recreate lightning network topology. Initialize router with channel
 	// between two nodes.
@@ -1422,8 +1477,14 @@ func TestSignatureAnnouncementFullProofWhenRemoteProof(t *testing.T) {
 		t.Fatalf("can't generate announcements: %v", err)
 	}
 
-	localKey := batch.nodeAnn1.NodeID
-	remoteKey := batch.nodeAnn2.NodeID
+	localKey, err := btcec.ParsePubKey(batch.nodeAnn1.NodeID[:], btcec.S256())
+	if err != nil {
+		t.Fatalf("unable to parse pubkey: %v", err)
+	}
+	remoteKey, err := btcec.ParsePubKey(batch.nodeAnn2.NodeID[:], btcec.S256())
+	if err != nil {
+		t.Fatalf("unable to parse pubkey: %v", err)
+	}
 
 	// Recreate lightning network topology. Initialize router with channel
 	// between two nodes.
@@ -1819,8 +1880,14 @@ func TestReceiveRemoteChannelUpdateFirst(t *testing.T) {
 		t.Fatalf("can't generate announcements: %v", err)
 	}
 
-	localKey := batch.nodeAnn1.NodeID
-	remoteKey := batch.nodeAnn2.NodeID
+	localKey, err := btcec.ParsePubKey(batch.nodeAnn1.NodeID[:], btcec.S256())
+	if err != nil {
+		t.Fatalf("unable to parse pubkey: %v", err)
+	}
+	remoteKey, err := btcec.ParsePubKey(batch.nodeAnn2.NodeID[:], btcec.S256())
+	if err != nil {
+		t.Fatalf("unable to parse pubkey: %v", err)
+	}
 
 	// Recreate the case where the remote node is sending us its ChannelUpdate
 	// before we have been able to process our own ChannelAnnouncement and