[n/n] Gossip 1.75

autopilot/graph.go

@@ -90,8 +90,8 @@ func (d *dbNode) Addrs() []net.Addr {
 // NOTE: Part of the autopilot.Node interface.
 func (d *dbNode) ForEachChannel(cb func(ChannelEdge) error) error {
 	return d.db.ForEachNodeChannel(d.tx, d.node.PubKeyBytes,
-		func(tx kvdb.RTx, ei *models.ChannelEdgeInfo, ep,
-			_ *models.ChannelEdgePolicy) error {
+		func(tx kvdb.RTx, ei models.ChannelEdgeInfo, ep,
+			_ models.ChannelEdgePolicy) error {
 
 			// Skip channels for which no outgoing edge policy is
 			// available.
@@ -105,16 +105,14 @@ func (d *dbNode) ForEachChannel(cb func(ChannelEdge) error) error {
 				return nil
 			}
 
-			node, err := d.db.FetchLightningNode(tx, ep.ToNode)
+			node, err := d.db.FetchLightningNode(tx, ep.GetToNode())
 			if err != nil {
 				return err
 			}
 
 			edge := ChannelEdge{
-				ChanID: lnwire.NewShortChanIDFromInt(
-					ep.ChannelID,
-				),
-				Capacity: ei.Capacity,
+				ChanID:   ep.SCID(),
+				Capacity: ei.GetCapacity(),
 				Peer: &dbNode{
 					tx:   tx,
 					db:   d.db,
@@ -236,15 +234,15 @@ func (d *databaseChannelGraph) addRandChannel(node1, node2 *btcec.PublicKey,
 	}
 
 	chanID := randChanID()
-	edge := &models.ChannelEdgeInfo{
+	edge := &models.ChannelEdgeInfo1{
 		ChannelID: chanID.ToUint64(),
 		Capacity:  capacity,
 	}
 	edge.AddNodeKeys(lnNode1, lnNode2, lnNode1, lnNode2)
 	if err := d.db.AddChannelEdge(edge); err != nil {
 		return nil, nil, err
 	}
-	edgePolicy := &models.ChannelEdgePolicy{
+	edgePolicy := &models.ChannelEdgePolicy1{
 		SigBytes:                  testSig.Serialize(),
 		ChannelID:                 chanID.ToUint64(),
 		LastUpdate:                time.Now(),
@@ -260,7 +258,7 @@ func (d *databaseChannelGraph) addRandChannel(node1, node2 *btcec.PublicKey,
 	if err := d.db.UpdateEdgePolicy(edgePolicy); err != nil {
 		return nil, nil, err
 	}
-	edgePolicy = &models.ChannelEdgePolicy{
+	edgePolicy = &models.ChannelEdgePolicy1{
 		SigBytes:                  testSig.Serialize(),
 		ChannelID:                 chanID.ToUint64(),
 		LastUpdate:                time.Now(),

channeldb/announcement_nonces.go

@@ -0,0 +1,161 @@
+package channeldb
+
+import (
+	"fmt"
+
+	"github.com/btcsuite/btcd/btcec/v2/schnorr/musig2"
+	"github.com/lightningnetwork/lnd/kvdb"
+	"github.com/lightningnetwork/lnd/lnwire"
+)
+
+var (
+	// announcementNoncesBucket is a top level bucket with the following
+	// structure: channel_id => node_nonce || bitcoin_nonce
+	announcementNoncesBucket = []byte("announcement-nonces")
+)
+
+type AnnouncementNonceStore interface {
+	SaveAnnouncementNonces(chanID lnwire.ChannelID,
+		nonces *AnnouncementNonces) error
+
+	GetAllAnnouncementNonces() (map[lnwire.ChannelID]AnnouncementNonces,
+		error)
+
+	DeleteAnnouncementNonces(chanID lnwire.ChannelID) error
+
+	GetAnnouncementNonces(chanID lnwire.ChannelID) (*AnnouncementNonces,
+		error)
+}
+
+// AnnouncementNonces holds the nonces used during the creating of a
+// ChannelAnnouncement2.
+type AnnouncementNonces struct {
+	Btc  [musig2.PubNonceSize]byte
+	Node [musig2.PubNonceSize]byte
+}
+
+// SaveAnnouncementNonces persist the given announcement nonces.
+func (c *ChannelStateDB) SaveAnnouncementNonces(chanID lnwire.ChannelID,
+	nonces *AnnouncementNonces) error {
+
+	chanIDCopy := make([]byte, 32)
+	copy(chanIDCopy, chanID[:])
+
+	scratch := make([]byte, musig2.PubNonceSize*2)
+	copy(scratch[:musig2.PubNonceSize], nonces.Node[:])
+	copy(scratch[musig2.PubNonceSize:], nonces.Btc[:])
+
+	return kvdb.Update(c.backend, func(tx kvdb.RwTx) error {
+		bucket, err := tx.CreateTopLevelBucket(
+			announcementNoncesBucket,
+		)
+		if err != nil {
+			return err
+		}
+
+		return bucket.Put(chanIDCopy, scratch)
+	}, func() {})
+}
+
+// GetAllAnnouncementNonces returns all the announcement nonce pairs currently
+// stored in the DB.
+func (c *ChannelStateDB) GetAllAnnouncementNonces() (
+	map[lnwire.ChannelID]AnnouncementNonces, error) {
+
+	m := make(map[lnwire.ChannelID]AnnouncementNonces)
+	err := kvdb.View(c.backend, func(tx kvdb.RTx) error {
+		bucket := tx.ReadBucket(announcementNoncesBucket)
+		if bucket == nil {
+			return nil
+		}
+
+		return bucket.ForEach(func(k, v []byte) error {
+			if len(k) != 32 {
+				return fmt.Errorf("invalid chan ID key")
+			}
+			if len(v) != musig2.PubNonceSize*2 {
+				return fmt.Errorf("wrong number of bytes")
+			}
+
+			var chanID lnwire.ChannelID
+			copy(chanID[:], k)
+
+			var btc, node [musig2.PubNonceSize]byte
+
+			copy(node[:], v[:musig2.PubNonceSize])
+			copy(btc[:], v[musig2.PubNonceSize:])
+
+			m[chanID] = AnnouncementNonces{
+				Btc:  btc,
+				Node: node,
+			}
+
+			return nil
+		})
+	}, func() {
+		m = make(map[lnwire.ChannelID]AnnouncementNonces)
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return m, nil
+}
+
+// GetAnnouncementNonces fetches the announcement nonces for the given channel
+// ID.
+func (c *ChannelStateDB) GetAnnouncementNonces(chanID lnwire.ChannelID) (
+	*AnnouncementNonces, error) {
+
+	chanIDCopy := make([]byte, 32)
+	copy(chanIDCopy, chanID[:])
+
+	var nonces AnnouncementNonces
+	err := kvdb.View(c.backend, func(tx kvdb.RTx) error {
+		bucket := tx.ReadBucket(announcementNoncesBucket)
+		if bucket == nil {
+			return ErrChannelNotFound
+		}
+
+		noncesBytes := bucket.Get(chanIDCopy)
+		if noncesBytes == nil {
+			return ErrChannelNotFound
+		}
+
+		if len(noncesBytes) != musig2.PubNonceSize*2 {
+			return fmt.Errorf("wrong number of bytes")
+		}
+
+		copy(nonces.Node[:], noncesBytes[:musig2.PubNonceSize])
+		copy(nonces.Btc[:], noncesBytes[musig2.PubNonceSize:])
+
+		return nil
+	}, func() {
+		nonces = AnnouncementNonces{}
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return &nonces, nil
+}
+
+// DeleteAnnouncementNonces deletes the announcement nonce pair stored under
+// the given channel ID key if an entry exists.
+func (c *ChannelStateDB) DeleteAnnouncementNonces(
+	chanID lnwire.ChannelID) error {
+
+	chanIDCopy := make([]byte, 32)
+	copy(chanIDCopy, chanID[:])
+
+	return kvdb.Update(c.backend, func(tx kvdb.RwTx) error {
+		bucket := tx.ReadWriteBucket(
+			announcementNoncesBucket,
+		)
+		if bucket == nil {
+			return nil
+		}
+
+		return bucket.Delete(chanIDCopy)
+	}, func() {})
+}

channeldb/announcement_nonces_test.go

@@ -0,0 +1,109 @@
+package channeldb
+
+import (
+	"math/rand"
+	"testing"
+
+	"github.com/lightningnetwork/lnd/lnwire"
+	"github.com/stretchr/testify/require"
+)
+
+// TestAnnouncementNonces tests the various announcement nonce pair CRUD
+// operations.
+func TestAnnouncementNonces(t *testing.T) {
+	cdb, err := MakeTestDB(t)
+	require.NoError(t, err)
+
+	db := cdb.ChannelStateDB()
+
+	// Show that the set of nonces is currently empty.
+	nonceSet, err := db.GetAllAnnouncementNonces()
+	require.NoError(t, err)
+	require.Empty(t, nonceSet)
+
+	// Generate a random channel ID.
+	chanID1 := randChannelID(t)
+
+	// Assert that there is no entry for this channel yet.
+	_, err = db.GetAnnouncementNonces(chanID1)
+	require.ErrorIs(t, err, ErrChannelNotFound)
+
+	// Insert an entry.
+	nonces1 := AnnouncementNonces{
+		Btc:  randNonce(t),
+		Node: randNonce(t),
+	}
+
+	err = db.SaveAnnouncementNonces(chanID1, &nonces1)
+	require.NoError(t, err)
+
+	// Assert that the entry is now returned.
+	n, err := db.GetAnnouncementNonces(chanID1)
+	require.NoError(t, err)
+	require.Equal(t, &nonces1, n)
+
+	nonceSet, err = db.GetAllAnnouncementNonces()
+	require.NoError(t, err)
+	require.EqualValues(t, map[lnwire.ChannelID]AnnouncementNonces{
+		chanID1: nonces1,
+	}, nonceSet)
+
+	// Add another entry.
+	chanID2 := randChannelID(t)
+	nonces2 := AnnouncementNonces{
+		Btc:  randNonce(t),
+		Node: randNonce(t),
+	}
+
+	err = db.SaveAnnouncementNonces(chanID2, &nonces2)
+	require.NoError(t, err)
+
+	n, err = db.GetAnnouncementNonces(chanID2)
+	require.NoError(t, err)
+	require.Equal(t, &nonces2, n)
+
+	nonceSet, err = db.GetAllAnnouncementNonces()
+	require.NoError(t, err)
+	require.EqualValues(t, map[lnwire.ChannelID]AnnouncementNonces{
+		chanID1: nonces1,
+		chanID2: nonces2,
+	}, nonceSet)
+
+	// Now, assert that deletion works.
+	err = db.DeleteAnnouncementNonces(chanID1)
+	require.NoError(t, err)
+
+	_, err = db.GetAnnouncementNonces(chanID1)
+	require.ErrorIs(t, err, ErrChannelNotFound)
+
+	nonceSet, err = db.GetAllAnnouncementNonces()
+	require.NoError(t, err)
+	require.EqualValues(t, map[lnwire.ChannelID]AnnouncementNonces{
+		chanID2: nonces2,
+	}, nonceSet)
+
+	err = db.DeleteAnnouncementNonces(chanID2)
+	require.NoError(t, err)
+
+	nonceSet, err = db.GetAllAnnouncementNonces()
+	require.NoError(t, err)
+	require.Empty(t, nonceSet)
+}
+
+func randChannelID(t *testing.T) lnwire.ChannelID {
+	var chanID lnwire.ChannelID
+
+	_, err := rand.Read(chanID[:])
+	require.NoError(t, err)
+
+	return chanID
+}
+
+func randNonce(t *testing.T) [66]byte {
+	var b [66]byte
+
+	_, err := rand.Read(b[:])
+	require.NoError(t, err)
+
+	return b
+}

channeldb/channel_cache_test.go

@@ -100,7 +100,7 @@ func assertHasChanEntries(t *testing.T, c *channelCache, start, end uint64) {
 // channelForInt generates a unique ChannelEdge given an integer.
 func channelForInt(i uint64) ChannelEdge {
 	return ChannelEdge{
-		Info: &models.ChannelEdgeInfo{
+		Info: &models.ChannelEdgeInfo1{
 			ChannelID: i,
 		},
 	}

channeldb/db.go

@@ -26,6 +26,7 @@ import (
 	"github.com/lightningnetwork/lnd/channeldb/migration29"
 	"github.com/lightningnetwork/lnd/channeldb/migration30"
 	"github.com/lightningnetwork/lnd/channeldb/migration31"
+	"github.com/lightningnetwork/lnd/channeldb/migration32"
 	"github.com/lightningnetwork/lnd/channeldb/migration_01_to_11"
 	"github.com/lightningnetwork/lnd/clock"
 	"github.com/lightningnetwork/lnd/invoices"
@@ -286,6 +287,10 @@ var (
 			number:    31,
 			migration: migration31.DeleteLastPublishedTxTLB,
 		},
+		{
+			number:    32,
+			migration: migration32.MigrateWaitingProofStore,
+		},
 	}
 
 	// optionalVersions stores all optional migrations that are applied