discovery,fundingmanager: avoid serialization in NotifyWhenOnline

discovery/gossiper.go

@@ -140,9 +140,7 @@ type Config struct {
 	// retry sending a peer message.
 	//
 	// NOTE: The peerChan channel must be buffered.
-	//
-	// TODO(wilmer): use [33]byte to avoid unnecessary serializations.
-	NotifyWhenOnline func(peer *btcec.PublicKey, peerChan chan<- lnpeer.Peer)
+	NotifyWhenOnline func(peerPubKey [33]byte, peerChan chan<- lnpeer.Peer)
 
 	// NotifyWhenOffline is a function that allows the gossiper to be
 	// notified when a certain peer disconnects, allowing it to request a

discovery/gossiper_test.go

@@ -734,9 +734,11 @@ func createTestCtx(startHeight uint32) (*testCtx, func(), error) {
 
 			return nil
 		},
-		NotifyWhenOnline: func(target *btcec.PublicKey,
+		NotifyWhenOnline: func(target [33]byte,
 			peerChan chan<- lnpeer.Peer) {
-			peerChan <- &mockPeer{target, nil, nil}
+
+			pk, _ := btcec.ParsePubKey(target[:], btcec.S256())
+			peerChan <- &mockPeer{pk, nil, nil}
 		},
 		NotifyWhenOffline: func(_ [33]byte) <-chan struct{} {
 			c := make(chan struct{})
@@ -981,11 +983,13 @@ func TestSignatureAnnouncementLocalFirst(t *testing.T) {
 	// Set up a channel that we can use to inspect the messages sent
 	// directly from the gossiper.
 	sentMsgs := make(chan lnwire.Message, 10)
-	ctx.gossiper.reliableSender.cfg.NotifyWhenOnline = func(target *btcec.PublicKey,
+	ctx.gossiper.reliableSender.cfg.NotifyWhenOnline = func(target [33]byte,
 		peerChan chan<- lnpeer.Peer) {
 
+		pk, _ := btcec.ParsePubKey(target[:], btcec.S256())
+
 		select {
-		case peerChan <- &mockPeer{target, sentMsgs, ctx.gossiper.quit}:
+		case peerChan <- &mockPeer{pk, sentMsgs, ctx.gossiper.quit}:
 		case <-ctx.gossiper.quit:
 		}
 	}
@@ -1178,11 +1182,13 @@ func TestOrphanSignatureAnnouncement(t *testing.T) {
 	// Set up a channel that we can use to inspect the messages sent
 	// directly from the gossiper.
 	sentMsgs := make(chan lnwire.Message, 10)
-	ctx.gossiper.reliableSender.cfg.NotifyWhenOnline = func(target *btcec.PublicKey,
+	ctx.gossiper.reliableSender.cfg.NotifyWhenOnline = func(target [33]byte,
 		peerChan chan<- lnpeer.Peer) {
 
+		pk, _ := btcec.ParsePubKey(target[:], btcec.S256())
+
 		select {
-		case peerChan <- &mockPeer{target, sentMsgs, ctx.gossiper.quit}:
+		case peerChan <- &mockPeer{pk, sentMsgs, ctx.gossiper.quit}:
 		case <-ctx.gossiper.quit:
 		}
 	}
@@ -1403,7 +1409,7 @@ func TestSignatureAnnouncementRetryAtStartup(t *testing.T) {
 	// channel through which it gets sent to control exactly when to
 	// dispatch it.
 	notifyPeers := make(chan chan<- lnpeer.Peer, 1)
-	ctx.gossiper.reliableSender.cfg.NotifyWhenOnline = func(peer *btcec.PublicKey,
+	ctx.gossiper.reliableSender.cfg.NotifyWhenOnline = func(peer [33]byte,
 		connectedChan chan<- lnpeer.Peer) {
 		notifyPeers <- connectedChan
 	}
@@ -1609,7 +1615,7 @@ func TestSignatureAnnouncementFullProofWhenRemoteProof(t *testing.T) {
 
 	// Override NotifyWhenOnline to return the remote peer which we expect
 	// meesages to be sent to.
-	ctx.gossiper.reliableSender.cfg.NotifyWhenOnline = func(peer *btcec.PublicKey,
+	ctx.gossiper.reliableSender.cfg.NotifyWhenOnline = func(peer [33]byte,
 		peerChan chan<- lnpeer.Peer) {
 
 		peerChan <- remotePeer
@@ -2442,7 +2448,7 @@ func TestReceiveRemoteChannelUpdateFirst(t *testing.T) {
 
 	// Override NotifyWhenOnline to return the remote peer which we expect
 	// meesages to be sent to.
-	ctx.gossiper.reliableSender.cfg.NotifyWhenOnline = func(peer *btcec.PublicKey,
+	ctx.gossiper.reliableSender.cfg.NotifyWhenOnline = func(peer [33]byte,
 		peerChan chan<- lnpeer.Peer) {
 
 		peerChan <- remotePeer
@@ -2983,7 +2989,7 @@ func TestSendChannelUpdateReliably(t *testing.T) {
 	// NotifyWhenOffline to instead give us access to the channel that will
 	// receive the notification.
 	notifyOnline := make(chan chan<- lnpeer.Peer, 1)
-	ctx.gossiper.reliableSender.cfg.NotifyWhenOnline = func(_ *btcec.PublicKey,
+	ctx.gossiper.reliableSender.cfg.NotifyWhenOnline = func(_ [33]byte,
 		peerChan chan<- lnpeer.Peer) {
 
 		notifyOnline <- peerChan
@@ -3360,13 +3366,13 @@ func TestPropagateChanPolicyUpdate(t *testing.T) {
 	// pubkey, and hand it our mock peer above.
 	notifyErr := make(chan error, 1)
 	ctx.gossiper.reliableSender.cfg.NotifyWhenOnline = func(
-		targetPub *btcec.PublicKey, peerChan chan<- lnpeer.Peer) {
+		targetPub [33]byte, peerChan chan<- lnpeer.Peer) {
 
-		if !targetPub.IsEqual(remoteKey) {
+		if !bytes.Equal(targetPub[:], remoteKey.SerializeCompressed()) {
 			notifyErr <- fmt.Errorf("reliableSender attempted to send the "+
 				"message to the wrong peer: expected %x got %x",
 				remoteKey.SerializeCompressed(),
-				targetPub.SerializeCompressed())
+				targetPub)
 		}
 
 		peerChan <- remotePeer

discovery/reliable_sender.go

@@ -3,7 +3,6 @@ package discovery
 import (
 	"sync"
 
-	"github.com/btcsuite/btcd/btcec"
 	"github.com/lightningnetwork/lnd/lnpeer"
 	"github.com/lightningnetwork/lnd/lnwire"
 )
@@ -16,9 +15,7 @@ type reliableSenderCfg struct {
 	// retry sending a peer message.
 	//
 	// NOTE: The peerChan channel must be buffered.
-	//
-	// TODO(wilmer): use [33]byte to avoid unnecessary serializations.
-	NotifyWhenOnline func(peer *btcec.PublicKey, peerChan chan<- lnpeer.Peer)
+	NotifyWhenOnline func(peerPubKey [33]byte, peerChan chan<- lnpeer.Peer)
 
 	// NotifyWhenOffline is a function that allows the gossiper to be
 	// notified when a certain peer disconnects, allowing it to request a
@@ -164,13 +161,12 @@ func (s *reliableSender) peerHandler(peerMgr peerManager, peerPubKey [33]byte) {
 
 	// We'll start by requesting a notification for when the peer
 	// reconnects.
-	pubKey, _ := btcec.ParsePubKey(peerPubKey[:], btcec.S256())
 	peerChan := make(chan lnpeer.Peer, 1)
 
 waitUntilOnline:
 	log.Debugf("Requesting online notification for peer=%x", peerPubKey)
 
-	s.cfg.NotifyWhenOnline(pubKey, peerChan)
+	s.cfg.NotifyWhenOnline(peerPubKey, peerChan)
 
 	var peer lnpeer.Peer
 out:

discovery/reliable_sender_test.go

@@ -18,9 +18,13 @@ func newTestReliableSender(t *testing.T) *reliableSender {
 	t.Helper()
 
 	cfg := &reliableSenderCfg{
-		NotifyWhenOnline: func(pubKey *btcec.PublicKey,
+		NotifyWhenOnline: func(pubKey [33]byte,
 			peerChan chan<- lnpeer.Peer) {
-			peerChan <- &mockPeer{pk: pubKey}
+			pk, err := btcec.ParsePubKey(pubKey[:], btcec.S256())
+			if err != nil {
+				t.Fatalf("unable to parse pubkey: %v", err)
+			}
+			peerChan <- &mockPeer{pk: pk}
 		},
 		NotifyWhenOffline: func(_ [33]byte) <-chan struct{} {
 			c := make(chan struct{}, 1)
@@ -78,7 +82,7 @@ func TestReliableSenderFlow(t *testing.T) {
 	notifyOnline := make(chan chan<- lnpeer.Peer, 2)
 	notifyOffline := make(chan chan struct{}, 1)
 
-	reliableSender.cfg.NotifyWhenOnline = func(_ *btcec.PublicKey,
+	reliableSender.cfg.NotifyWhenOnline = func(_ [33]byte,
 		peerChan chan<- lnpeer.Peer) {
 		notifyOnline <- peerChan
 	}
@@ -194,7 +198,7 @@ func TestReliableSenderStaleMessages(t *testing.T) {
 	// Override NotifyWhenOnline to provide the notification channel so that
 	// we can control when notifications get dispatched.
 	notifyOnline := make(chan chan<- lnpeer.Peer, 1)
-	reliableSender.cfg.NotifyWhenOnline = func(_ *btcec.PublicKey,
+	reliableSender.cfg.NotifyWhenOnline = func(_ [33]byte,
 		peerChan chan<- lnpeer.Peer) {
 		notifyOnline <- peerChan
 	}