channeldb: prep waiting proof store for taproot proofs

With a migration to migrate existing entries in the waiting proof store
to use a type byte prefix.

Author: ellemouton

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

channeldb/log.go

@@ -10,6 +10,7 @@ import (
 	"github.com/lightningnetwork/lnd/channeldb/migration24"
 	"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/kvdb"
 )
@@ -42,5 +43,6 @@ func UseLogger(logger btclog.Logger) {
 	migration24.UseLogger(logger)
 	migration30.UseLogger(logger)
 	migration31.UseLogger(logger)
+	migration32.UseLogger(logger)
 	kvdb.UseLogger(logger)
 }

channeldb/migration32/log.go

@@ -0,0 +1,14 @@
+package migration32
+
+import (
+	"github.com/btcsuite/btclog"
+)
+
+// log is a logger that is initialized as disabled.  This means the package will
+// not perform any logging by default until a logger is set.
+var log = btclog.Disabled
+
+// UseLogger uses a specified Logger to output package logging info.
+func UseLogger(logger btclog.Logger) {
+	log = logger
+}

channeldb/migration32/migration.go

@@ -0,0 +1,55 @@
+package migration32
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/lightningnetwork/lnd/kvdb"
+)
+
+// waitingProofsBucketKey byte string name of the waiting proofs store.
+var waitingProofsBucketKey = []byte("waitingproofs")
+
+// MigrateWaitingProofStore migrates the waiting proof store so that all entries
+// are prefixed with a type byte.
+func MigrateWaitingProofStore(tx kvdb.RwTx) error {
+	log.Infof("Migrating waiting proof store")
+
+	bucket := tx.ReadWriteBucket(waitingProofsBucketKey)
+
+	// If the bucket does not exist yet, then there are no entries to
+	// migrate.
+	if bucket == nil {
+		return nil
+	}
+
+	return bucket.ForEach(func(k, v []byte) error {
+		// Skip buckets fields.
+		if v == nil {
+			return nil
+		}
+
+		// Read in the waiting proof using the legacy decoding method.
+		var proof WaitingProof
+		if err := proof.LegacyDecode(bytes.NewReader(v)); err != nil {
+			return err
+		}
+
+		// Do sanity check to ensure that the proof key is the same as
+		// the key used to store the proof.
+		key := proof.Key()
+		if !bytes.Equal(key[:], k) {
+			return fmt.Errorf("proof key (%x) does not match "+
+				"the key used to store the proof: %x", key, k)
+		}
+
+		// Re-encode the proof using the new, type-prefixed encoding.
+		var b bytes.Buffer
+		err := proof.UpdatedEncode(&b)
+		if err != nil {
+			return err
+		}
+
+		return bucket.Put(k, b.Bytes())
+	})
+}

channeldb/migration32/migration_test.go

@@ -0,0 +1,100 @@
+package migration32
+
+import (
+	"bytes"
+	"encoding/hex"
+	"testing"
+
+	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/btcsuite/btcd/btcec/v2/ecdsa"
+	lnwire "github.com/lightningnetwork/lnd/channeldb/migration/lnwire21"
+	"github.com/lightningnetwork/lnd/channeldb/migtest"
+	"github.com/lightningnetwork/lnd/kvdb"
+	"github.com/stretchr/testify/require"
+)
+
+var (
+	testRBytes, _ = hex.DecodeString("8ce2bc69281ce27da07e6683571" +
+		"319d18e949ddfa2965fb6caa1bf0314f882d7")
+	testSBytes, _ = hex.DecodeString("299105481d63e0f4bc2a" +
+		"88121167221b6700d72a0ead154c03be696a292d24ae")
+	testRScalar = new(btcec.ModNScalar)
+	testSScalar = new(btcec.ModNScalar)
+	_           = testRScalar.SetByteSlice(testRBytes)
+	_           = testSScalar.SetByteSlice(testSBytes)
+	testSig     = ecdsa.NewSignature(testRScalar, testSScalar)
+
+	sig, _ = lnwire.NewSigFromSignature(testSig)
+
+	wp1 = &WaitingProof{
+		AnnounceSignatures: &lnwire.AnnounceSignatures{
+			ChannelID:        lnwire.ChannelID{1},
+			ShortChannelID:   lnwire.NewShortChanIDFromInt(1),
+			NodeSignature:    sig,
+			BitcoinSignature: sig,
+			ExtraOpaqueData:  []byte{1, 2, 3, 4},
+		},
+		isRemote: false,
+	}
+
+	wp2 = &WaitingProof{
+		AnnounceSignatures: &lnwire.AnnounceSignatures{
+			ChannelID:        lnwire.ChannelID{2},
+			ShortChannelID:   lnwire.NewShortChanIDFromInt(2),
+			NodeSignature:    sig,
+			BitcoinSignature: sig,
+		},
+		isRemote: true,
+	}
+)
+
+// TestMigrationWaitingProofStore tests that the MigrateWaitingProofStore
+// function works as expected.
+func TestMigrateWaitingProofStore(t *testing.T) {
+	var (
+		key1           = wp1.Key()
+		key2           = wp2.Key()
+		wp1BytesBefore bytes.Buffer
+		wp2BytesBefore bytes.Buffer
+		wp1BytesAfter  bytes.Buffer
+		wp2BytesAfter  bytes.Buffer
+	)
+
+	err := wp1.LegacyEncode(&wp1BytesBefore)
+	require.NoError(t, err)
+
+	err = wp2.LegacyEncode(&wp2BytesBefore)
+	require.NoError(t, err)
+
+	wpStoreBefore := map[string]interface{}{
+		string(key1[:]): wp1BytesBefore.String(),
+		string(key2[:]): wp2BytesBefore.String(),
+	}
+
+	err = wp1.UpdatedEncode(&wp1BytesAfter)
+	require.NoError(t, err)
+
+	err = wp2.UpdatedEncode(&wp2BytesAfter)
+	require.NoError(t, err)
+
+	wpStoreAfter := map[string]interface{}{
+		string(key1[:]): wp1BytesAfter.String(),
+		string(key2[:]): wp2BytesAfter.String(),
+	}
+
+	before := func(tx kvdb.RwTx) error {
+		return migtest.RestoreDB(
+			tx, waitingProofsBucketKey, wpStoreBefore,
+		)
+	}
+
+	after := func(tx kvdb.RwTx) error {
+		return migtest.VerifyDB(
+			tx, waitingProofsBucketKey, wpStoreAfter,
+		)
+	}
+
+	migtest.ApplyMigration(
+		t, before, after, MigrateWaitingProofStore, false,
+	)
+}

channeldb/migration32/waitingproof.go

@@ -0,0 +1,100 @@
+package migration32
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"io"
+
+	lnwire "github.com/lightningnetwork/lnd/channeldb/migration/lnwire21"
+)
+
+var byteOrder = binary.BigEndian
+
+// WaitingProofType represents the type of the encoded waiting proof.
+type WaitingProofType uint8
+
+const (
+	// WaitingProofTypeLegacy represents a waiting proof for legacy P2WSH
+	// channels.
+	WaitingProofTypeLegacy WaitingProofType = 0
+)
+
+// WaitingProofKey is the proof key which uniquely identifies the waiting
+// proof object. The goal of this key is distinguish the local and remote
+// proof for the same channel id.
+type WaitingProofKey [9]byte
+
+// WaitingProof is the storable object, which encapsulate the half proof and
+// the information about from which side this proof came. This structure is
+// needed to make channel proof exchange persistent, so that after client
+// restart we may receive remote/local half proof and process it.
+type WaitingProof struct {
+	*lnwire.AnnounceSignatures
+	isRemote bool
+}
+
+// Key returns the key which uniquely identifies waiting proof.
+func (p *WaitingProof) Key() WaitingProofKey {
+	var key [9]byte
+	binary.BigEndian.PutUint64(key[:8], p.ShortChannelID.ToUint64())
+
+	if p.isRemote {
+		key[8] = 1
+	}
+
+	return key
+}
+
+// UpdatedEncode writes the internal representation of waiting proof in byte
+// stream using the new format that is prefixed with a type byte.
+func (p *WaitingProof) UpdatedEncode(w io.Writer) error {
+	// Write the type byte.
+	err := binary.Write(w, byteOrder, WaitingProofTypeLegacy)
+	if err != nil {
+		return err
+	}
+
+	if err := binary.Write(w, byteOrder, p.isRemote); err != nil {
+		return err
+	}
+
+	buf, ok := w.(*bytes.Buffer)
+	if !ok {
+		return fmt.Errorf("expect io.Writer to be *bytes.Buffer")
+	}
+
+	return p.AnnounceSignatures.Encode(buf, 0)
+}
+
+// LegacyEncode writes the internal representation of waiting proof in byte
+// stream using the legacy format.
+func (p *WaitingProof) LegacyEncode(w io.Writer) error {
+	if err := binary.Write(w, byteOrder, p.isRemote); err != nil {
+		return err
+	}
+
+	buf, ok := w.(*bytes.Buffer)
+	if !ok {
+		return fmt.Errorf("expect io.Writer to be *bytes.Buffer")
+	}
+
+	return p.AnnounceSignatures.Encode(buf, 0)
+}
+
+// LegacyDecode reads the data from the byte stream and initializes the
+// waiting proof object with it.
+func (p *WaitingProof) LegacyDecode(r io.Reader) error {
+	if err := binary.Read(r, byteOrder, &p.isRemote); err != nil {
+		return err
+	}
+
+	msg := &lnwire.AnnounceSignatures{}
+	if err := msg.Decode(r, 0); err != nil {
+		return err
+	}
+
+	p.AnnounceSignatures = msg
+
+	return nil
+}