Merge pull request #2669 from cfromknecht/use-netann-in-discovery

netann+discovery+server: consolidate network announcements to netann pkg

discovery/chan_series.go

@@ -6,6 +6,7 @@ import (
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/lightningnetwork/lnd/channeldb"
 	"github.com/lightningnetwork/lnd/lnwire"
+	"github.com/lightningnetwork/lnd/netann"
 	"github.com/lightningnetwork/lnd/routing/route"
 )
 
@@ -119,7 +120,7 @@ func (c *ChanSeries) UpdatesInHorizon(chain chainhash.Hash,
 			continue
 		}
 
-		chanAnn, edge1, edge2, err := CreateChanAnnouncement(
+		chanAnn, edge1, edge2, err := netann.CreateChanAnnouncement(
 			channel.Info.AuthProof, channel.Info, channel.Policy1,
 			channel.Policy2,
 		)
@@ -258,7 +259,7 @@ func (c *ChanSeries) FetchChanAnns(chain chainhash.Hash,
 			continue
 		}
 
-		chanAnn, edge1, edge2, err := CreateChanAnnouncement(
+		chanAnn, edge1, edge2, err := netann.CreateChanAnnouncement(
 			channel.Info.AuthProof, channel.Info, channel.Policy1,
 			channel.Policy2,
 		)
@@ -323,20 +324,7 @@ func (c *ChanSeries) FetchChanUpdates(chain chainhash.Hash,
 
 	chanUpdates := make([]*lnwire.ChannelUpdate, 0, 2)
 	if e1 != nil {
-		chanUpdate := &lnwire.ChannelUpdate{
-			ChainHash:       chanInfo.ChainHash,
-			ShortChannelID:  shortChanID,
-			Timestamp:       uint32(e1.LastUpdate.Unix()),
-			MessageFlags:    e1.MessageFlags,
-			ChannelFlags:    e1.ChannelFlags,
-			TimeLockDelta:   e1.TimeLockDelta,
-			HtlcMinimumMsat: e1.MinHTLC,
-			HtlcMaximumMsat: e1.MaxHTLC,
-			BaseFee:         uint32(e1.FeeBaseMSat),
-			FeeRate:         uint32(e1.FeeProportionalMillionths),
-			ExtraOpaqueData: e1.ExtraOpaqueData,
-		}
-		chanUpdate.Signature, err = lnwire.NewSigFromRawSignature(e1.SigBytes)
+		chanUpdate, err := netann.ChannelUpdateFromEdge(chanInfo, e1)
 		if err != nil {
 			return nil, err
 		}
@@ -344,20 +332,7 @@ func (c *ChanSeries) FetchChanUpdates(chain chainhash.Hash,
 		chanUpdates = append(chanUpdates, chanUpdate)
 	}
 	if e2 != nil {
-		chanUpdate := &lnwire.ChannelUpdate{
-			ChainHash:       chanInfo.ChainHash,
-			ShortChannelID:  shortChanID,
-			Timestamp:       uint32(e2.LastUpdate.Unix()),
-			MessageFlags:    e2.MessageFlags,
-			ChannelFlags:    e2.ChannelFlags,
-			TimeLockDelta:   e2.TimeLockDelta,
-			HtlcMinimumMsat: e2.MinHTLC,
-			HtlcMaximumMsat: e2.MaxHTLC,
-			BaseFee:         uint32(e2.FeeBaseMSat),
-			FeeRate:         uint32(e2.FeeProportionalMillionths),
-			ExtraOpaqueData: e2.ExtraOpaqueData,
-		}
-		chanUpdate.Signature, err = lnwire.NewSigFromRawSignature(e2.SigBytes)
+		chanUpdate, err := netann.ChannelUpdateFromEdge(chanInfo, e2)
 		if err != nil {
 			return nil, err
 		}

discovery/gossiper.go

@@ -20,6 +20,7 @@ import (
 	"github.com/lightningnetwork/lnd/lnwallet"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/multimutex"
+	"github.com/lightningnetwork/lnd/netann"
 	"github.com/lightningnetwork/lnd/routing"
 	"github.com/lightningnetwork/lnd/routing/route"
 	"github.com/lightningnetwork/lnd/ticker"
@@ -350,15 +351,6 @@ func New(cfg Config, selfKey *btcec.PublicKey) *AuthenticatedGossiper {
 	return gossiper
 }
 
-// updatedChanPolicies is a set of channel policies that have been successfully
-// updated and written to disk, or an error if the policy update failed. This
-// struct's map field is intended to be used for updating channel policies on
-// the link layer.
-type updatedChanPolicies struct {
-	chanPolicies map[wire.OutPoint]*channeldb.ChannelEdgePolicy
-	err          error
-}
-
 // EdgeWithInfo contains the information that is required to update an edge.
 type EdgeWithInfo struct {
 	// Info describes the channel.
@@ -1364,6 +1356,22 @@ func (d *AuthenticatedGossiper) processChanPolicyUpdate(
 	return chanUpdates, nil
 }
 
+// remotePubFromChanInfo returns the public key of the remote peer given a
+// ChannelEdgeInfo that describe a channel we have with them.
+func remotePubFromChanInfo(chanInfo *channeldb.ChannelEdgeInfo,
+	chanFlags lnwire.ChanUpdateChanFlags) [33]byte {
+
+	var remotePubKey [33]byte
+	switch {
+	case chanFlags&lnwire.ChanUpdateDirection == 0:
+		remotePubKey = chanInfo.NodeKey2Bytes
+	case chanFlags&lnwire.ChanUpdateDirection == 1:
+		remotePubKey = chanInfo.NodeKey1Bytes
+	}
+
+	return remotePubKey
+}
+
 // processRejectedEdge examines a rejected edge to see if we can extract any
 // new announcements from it.  An edge will get rejected if we already added
 // the same edge without AuthProof to the graph. If the received announcement
@@ -1400,7 +1408,7 @@ func (d *AuthenticatedGossiper) processRejectedEdge(
 
 	// We'll then create then validate the new fully assembled
 	// announcement.
-	chanAnn, e1Ann, e2Ann, err := CreateChanAnnouncement(
+	chanAnn, e1Ann, e2Ann, err := netann.CreateChanAnnouncement(
 		proof, chanInfo, e1, e2,
 	)
 	if err != nil {
@@ -2157,7 +2165,7 @@ func (d *AuthenticatedGossiper) processNetworkAnnouncement(
 						msg.ChannelID,
 						peerID)
 
-					chanAnn, _, _, err := CreateChanAnnouncement(
+					chanAnn, _, _, err := netann.CreateChanAnnouncement(
 						chanInfo.AuthProof, chanInfo,
 						e1, e2,
 					)
@@ -2240,7 +2248,7 @@ func (d *AuthenticatedGossiper) processNetworkAnnouncement(
 			dbProof.BitcoinSig1Bytes = oppositeProof.BitcoinSignature.ToSignatureBytes()
 			dbProof.BitcoinSig2Bytes = msg.BitcoinSignature.ToSignatureBytes()
 		}
-		chanAnn, e1Ann, e2Ann, err := CreateChanAnnouncement(
+		chanAnn, e1Ann, e2Ann, err := netann.CreateChanAnnouncement(
 			&dbProof, chanInfo, e1, e2,
 		)
 		if err != nil {
@@ -2445,42 +2453,23 @@ func (d *AuthenticatedGossiper) updateChannel(info *channeldb.ChannelEdgeInfo,
 	edge *channeldb.ChannelEdgePolicy) (*lnwire.ChannelAnnouncement,
 	*lnwire.ChannelUpdate, error) {
 
-	// Make sure timestamp is always increased, such that our update gets
-	// propagated.
-	timestamp := time.Now().Unix()
-	if timestamp <= edge.LastUpdate.Unix() {
-		timestamp = edge.LastUpdate.Unix() + 1
-	}
-	edge.LastUpdate = time.Unix(timestamp, 0)
+	// Parse the unsigned edge into a channel update.
+	chanUpdate := netann.UnsignedChannelUpdateFromEdge(info, edge)
 
-	chanUpdate := &lnwire.ChannelUpdate{
-		ChainHash:       info.ChainHash,
-		ShortChannelID:  lnwire.NewShortChanIDFromInt(edge.ChannelID),
-		Timestamp:       uint32(timestamp),
-		MessageFlags:    edge.MessageFlags,
-		ChannelFlags:    edge.ChannelFlags,
-		TimeLockDelta:   edge.TimeLockDelta,
-		HtlcMinimumMsat: edge.MinHTLC,
-		HtlcMaximumMsat: edge.MaxHTLC,
-		BaseFee:         uint32(edge.FeeBaseMSat),
-		FeeRate:         uint32(edge.FeeProportionalMillionths),
-		ExtraOpaqueData: edge.ExtraOpaqueData,
-	}
-
-	// With the update applied, we'll generate a new signature over a
-	// digest of the channel announcement itself.
-	sig, err := SignAnnouncement(d.cfg.AnnSigner, d.selfKey, chanUpdate)
+	// We'll generate a new signature over a digest of the channel
+	// announcement itself and update the timestamp to ensure it propagate.
+	err := netann.SignChannelUpdate(
+		d.cfg.AnnSigner, d.selfKey, chanUpdate,
+		netann.ChanUpdSetTimestamp,
+	)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	// Next, we'll set the new signature in place, and update the reference
 	// in the backing slice.
-	edge.SetSigBytes(sig.Serialize())
-	chanUpdate.Signature, err = lnwire.NewSigFromSignature(sig)
-	if err != nil {
-		return nil, nil, err
-	}
+	edge.LastUpdate = time.Unix(int64(chanUpdate.Timestamp), 0)
+	edge.SigBytes = chanUpdate.Signature.ToSignatureBytes()
 
 	// To ensure that our signature is valid, we'll verify it ourself
 	// before committing it to the slice returned.

discovery/gossiper_test.go

@@ -26,6 +26,7 @@ import (
 	"github.com/lightningnetwork/lnd/lnpeer"
 	"github.com/lightningnetwork/lnd/lntest/wait"
 	"github.com/lightningnetwork/lnd/lnwire"
+	"github.com/lightningnetwork/lnd/netann"
 	"github.com/lightningnetwork/lnd/routing"
 	"github.com/lightningnetwork/lnd/routing/route"
 	"github.com/lightningnetwork/lnd/ticker"
@@ -550,7 +551,7 @@ func createNodeAnnouncement(priv *btcec.PrivateKey,
 	}
 
 	signer := mockSigner{priv}
-	sig, err := SignAnnouncement(&signer, priv.PubKey(), a)
+	sig, err := netann.SignAnnouncement(&signer, priv.PubKey(), a)
 	if err != nil {
 		return nil, err
 	}
@@ -602,7 +603,7 @@ func createUpdateAnnouncement(blockHeight uint32,
 func signUpdate(nodeKey *btcec.PrivateKey, a *lnwire.ChannelUpdate) error {
 	pub := nodeKey.PubKey()
 	signer := mockSigner{nodeKey}
-	sig, err := SignAnnouncement(&signer, pub, a)
+	sig, err := netann.SignAnnouncement(&signer, pub, a)
 	if err != nil {
 		return err
 	}
@@ -644,7 +645,7 @@ func createRemoteChannelAnnouncement(blockHeight uint32,
 
 	pub := nodeKeyPriv1.PubKey()
 	signer := mockSigner{nodeKeyPriv1}
-	sig, err := SignAnnouncement(&signer, pub, a)
+	sig, err := netann.SignAnnouncement(&signer, pub, a)
 	if err != nil {
 		return nil, err
 	}
@@ -655,7 +656,7 @@ func createRemoteChannelAnnouncement(blockHeight uint32,
 
 	pub = nodeKeyPriv2.PubKey()
 	signer = mockSigner{nodeKeyPriv2}
-	sig, err = SignAnnouncement(&signer, pub, a)
+	sig, err = netann.SignAnnouncement(&signer, pub, a)
 	if err != nil {
 		return nil, err
 	}
@@ -666,7 +667,7 @@ func createRemoteChannelAnnouncement(blockHeight uint32,
 
 	pub = bitcoinKeyPriv1.PubKey()
 	signer = mockSigner{bitcoinKeyPriv1}
-	sig, err = SignAnnouncement(&signer, pub, a)
+	sig, err = netann.SignAnnouncement(&signer, pub, a)
 	if err != nil {
 		return nil, err
 	}
@@ -677,7 +678,7 @@ func createRemoteChannelAnnouncement(blockHeight uint32,
 
 	pub = bitcoinKeyPriv2.PubKey()
 	signer = mockSigner{bitcoinKeyPriv2}
-	sig, err = SignAnnouncement(&signer, pub, a)
+	sig, err = netann.SignAnnouncement(&signer, pub, a)
 	if err != nil {
 		return nil, err
 	}

discovery/utils.go

@@ -1,154 +0,0 @@
-package discovery
-
-import (
-	"github.com/btcsuite/btcd/btcec"
-	"github.com/go-errors/errors"
-	"github.com/lightningnetwork/lnd/channeldb"
-	"github.com/lightningnetwork/lnd/lnwallet"
-	"github.com/lightningnetwork/lnd/lnwire"
-)
-
-// CreateChanAnnouncement is a helper function which creates all channel
-// announcements given the necessary channel related database items. This
-// function is used to transform out database structs into the corresponding wire
-// structs for announcing new channels to other peers, or simply syncing up a
-// peer's initial routing table upon connect.
-func CreateChanAnnouncement(chanProof *channeldb.ChannelAuthProof,
-	chanInfo *channeldb.ChannelEdgeInfo,
-	e1, e2 *channeldb.ChannelEdgePolicy) (*lnwire.ChannelAnnouncement,
-	*lnwire.ChannelUpdate, *lnwire.ChannelUpdate, error) {
-
-	// First, using the parameters of the channel, along with the channel
-	// authentication chanProof, we'll create re-create the original
-	// authenticated channel announcement.
-	chanID := lnwire.NewShortChanIDFromInt(chanInfo.ChannelID)
-	chanAnn := &lnwire.ChannelAnnouncement{
-		ShortChannelID:  chanID,
-		NodeID1:         chanInfo.NodeKey1Bytes,
-		NodeID2:         chanInfo.NodeKey2Bytes,
-		ChainHash:       chanInfo.ChainHash,
-		BitcoinKey1:     chanInfo.BitcoinKey1Bytes,
-		BitcoinKey2:     chanInfo.BitcoinKey2Bytes,
-		Features:        lnwire.NewRawFeatureVector(),
-		ExtraOpaqueData: chanInfo.ExtraOpaqueData,
-	}
-
-	var err error
-	chanAnn.BitcoinSig1, err = lnwire.NewSigFromRawSignature(
-		chanProof.BitcoinSig1Bytes,
-	)
-	if err != nil {
-		return nil, nil, nil, err
-	}
-	chanAnn.BitcoinSig2, err = lnwire.NewSigFromRawSignature(
-		chanProof.BitcoinSig2Bytes,
-	)
-	if err != nil {
-		return nil, nil, nil, err
-	}
-	chanAnn.NodeSig1, err = lnwire.NewSigFromRawSignature(
-		chanProof.NodeSig1Bytes,
-	)
-	if err != nil {
-		return nil, nil, nil, err
-	}
-	chanAnn.NodeSig2, err = lnwire.NewSigFromRawSignature(
-		chanProof.NodeSig2Bytes,
-	)
-	if err != nil {
-		return nil, nil, nil, err
-	}
-
-	// We'll unconditionally queue the channel's existence chanProof as it
-	// will need to be processed before either of the channel update
-	// networkMsgs.
-
-	// Since it's up to a node's policy as to whether they advertise the
-	// edge in a direction, we don't create an advertisement if the edge is
-	// nil.
-	var edge1Ann, edge2Ann *lnwire.ChannelUpdate
-	if e1 != nil {
-		edge1Ann = &lnwire.ChannelUpdate{
-			ChainHash:       chanInfo.ChainHash,
-			ShortChannelID:  chanID,
-			Timestamp:       uint32(e1.LastUpdate.Unix()),
-			MessageFlags:    e1.MessageFlags,
-			ChannelFlags:    e1.ChannelFlags,
-			TimeLockDelta:   e1.TimeLockDelta,
-			HtlcMinimumMsat: e1.MinHTLC,
-			HtlcMaximumMsat: e1.MaxHTLC,
-			BaseFee:         uint32(e1.FeeBaseMSat),
-			FeeRate:         uint32(e1.FeeProportionalMillionths),
-			ExtraOpaqueData: e1.ExtraOpaqueData,
-		}
-		edge1Ann.Signature, err = lnwire.NewSigFromRawSignature(e1.SigBytes)
-		if err != nil {
-			return nil, nil, nil, err
-		}
-	}
-	if e2 != nil {
-		edge2Ann = &lnwire.ChannelUpdate{
-			ChainHash:       chanInfo.ChainHash,
-			ShortChannelID:  chanID,
-			Timestamp:       uint32(e2.LastUpdate.Unix()),
-			MessageFlags:    e2.MessageFlags,
-			ChannelFlags:    e2.ChannelFlags,
-			TimeLockDelta:   e2.TimeLockDelta,
-			HtlcMinimumMsat: e2.MinHTLC,
-			HtlcMaximumMsat: e2.MaxHTLC,
-			BaseFee:         uint32(e2.FeeBaseMSat),
-			FeeRate:         uint32(e2.FeeProportionalMillionths),
-			ExtraOpaqueData: e2.ExtraOpaqueData,
-		}
-		edge2Ann.Signature, err = lnwire.NewSigFromRawSignature(e2.SigBytes)
-		if err != nil {
-			return nil, nil, nil, err
-		}
-	}
-
-	return chanAnn, edge1Ann, edge2Ann, nil
-}
-
-// SignAnnouncement is a helper function which is used to sign any outgoing
-// channel node node announcement messages.
-func SignAnnouncement(signer lnwallet.MessageSigner, pubKey *btcec.PublicKey,
-	msg lnwire.Message) (*btcec.Signature, error) {
-
-	var (
-		data []byte
-		err  error
-	)
-
-	switch m := msg.(type) {
-	case *lnwire.ChannelAnnouncement:
-		data, err = m.DataToSign()
-	case *lnwire.ChannelUpdate:
-		data, err = m.DataToSign()
-	case *lnwire.NodeAnnouncement:
-		data, err = m.DataToSign()
-	default:
-		return nil, errors.New("can't sign message " +
-			"of this format")
-	}
-	if err != nil {
-		return nil, errors.Errorf("unable to get data to sign: %v", err)
-	}
-
-	return signer.SignMessage(pubKey, data)
-}
-
-// remotePubFromChanInfo returns the public key of the remote peer given a
-// ChannelEdgeInfo that describe a channel we have with them.
-func remotePubFromChanInfo(chanInfo *channeldb.ChannelEdgeInfo,
-	chanFlags lnwire.ChanUpdateChanFlags) [33]byte {
-
-	var remotePubKey [33]byte
-	switch {
-	case chanFlags&lnwire.ChanUpdateDirection == 0:
-		remotePubKey = chanInfo.NodeKey2Bytes
-	case chanFlags&lnwire.ChanUpdateDirection == 1:
-		remotePubKey = chanInfo.NodeKey1Bytes
-	}
-
-	return remotePubKey
-}