Merge pull request #10672 from ellemouton/fix/private-taproot-v1-funding-script

graph/db: honor taproot feature bit in v1 funding script construction

Author: ellemouton

docs/release-notes/release-notes-0.21.0.md

@@ -61,6 +61,14 @@
   these valid no-reply pings instead of disconnecting peers, restoring
   compatibility with implementations that pad `channel_reestablish` messages
   with them.
+ 
+* [Fixed `FundingPKScript` to honor the taproot feature bit on v1 channel
+  edges](https://github.com/lightningnetwork/lnd/pull/10672). Private taproot
+  channels stored as v1 gossip objects with the taproot staging feature bit
+  were having their funding scripts incorrectly reconstructed as legacy P2WSH
+  multisig. This affected read paths such as `ChannelView`, which rebuilds
+  the chain watch filter on restart. This was a pre-existing bug since
+  private taproot channels were first introduced.
 
 # New Features
 

graph/db/graph_test.go

@@ -23,6 +23,7 @@ import (
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightningnetwork/lnd/fn/v2"
 	"github.com/lightningnetwork/lnd/graph/db/models"
+	"github.com/lightningnetwork/lnd/input"
 	"github.com/lightningnetwork/lnd/kvdb"
 	"github.com/lightningnetwork/lnd/lntest/wait"
 	"github.com/lightningnetwork/lnd/lnwire"
@@ -209,6 +210,10 @@ var versionedTests = []versionedTest{
 		name: "channel view",
 		test: testChannelView,
 	},
+	{
+		name: "channel view taproot v1 round trip",
+		test: testChannelViewTaprootV1RoundTrip,
+	},
 }
 
 // TestVersionedDBs runs various tests against both v1 and v2 versioned
@@ -3897,6 +3902,70 @@ func testChannelView(t *testing.T, v lnwire.GossipVersion) {
 	assertChanViewEqual(t, channelView, edgePoints)
 }
 
+// testChannelViewTaprootV1RoundTrip tests that a taproot channel persisted as a
+// v1 edge can be read back from ChannelView() with the correct taproot funding
+// script.
+func testChannelViewTaprootV1RoundTrip(t *testing.T, v lnwire.GossipVersion) {
+	t.Parallel()
+
+	if v != lnwire.GossipVersion1 {
+		t.Skip("only relevant for v1 taproot workaround channels")
+	}
+
+	ctx := t.Context()
+	graph := NewVersionedGraph(MakeTestGraph(t), v)
+
+	node1 := createTestVertex(t, v)
+	require.NoError(t, graph.AddNode(ctx, node1))
+	node2 := createTestVertex(t, v)
+	require.NoError(t, graph.AddNode(ctx, node2))
+
+	node1Pub, err := node1.PubKey()
+	require.NoError(t, err)
+	node2Pub, err := node2.PubKey()
+	require.NoError(t, err)
+
+	node1Vertex := route.NewVertex(node1Pub)
+	node2Vertex := route.NewVertex(node2Pub)
+	outpoint := wire.OutPoint{
+		Hash:  rev,
+		Index: 1,
+	}
+
+	// Persist a synthetic v1 channel that advertises the taproot staging
+	// bit. This reproduces the serialization path exercised by older graph
+	// entries.
+	edgeInfo, err := models.NewV1Channel(
+		1, *chaincfg.MainNetParams.GenesisHash,
+		node1Vertex, node2Vertex,
+		&models.ChannelV1Fields{
+			BitcoinKey1Bytes: node1Vertex,
+			BitcoinKey2Bytes: node2Vertex,
+			ExtraOpaqueData:  make([]byte, 0),
+		},
+		models.WithChannelPoint(outpoint),
+		models.WithCapacity(9000),
+		models.WithFeatures(lnwire.NewRawFeatureVector(
+			lnwire.SimpleTaprootChannelsRequiredStaging,
+		)),
+	)
+	require.NoError(t, err)
+	require.NoError(t, graph.AddChannelEdge(ctx, edgeInfo))
+
+	// The fix should make ChannelView reconstruct the taproot funding
+	// script for v1 channels that advertise the taproot staging bit.
+	expectedScript, _, err := input.GenTaprootFundingScript(
+		node1Pub, node2Pub, 0, fn.None[chainhash.Hash](),
+	)
+	require.NoError(t, err)
+
+	channelView, err := graph.ChannelView(ctx)
+	require.NoError(t, err)
+	require.Len(t, channelView, 1)
+	require.Equal(t, expectedScript, channelView[0].FundingPkScript)
+	require.Equal(t, outpoint, channelView[0].OutPoint)
+}
+
 // testIncompleteChannelPolicies tests that a channel that only has a policy
 // specified on one end is properly returned in ForEachChannel calls from
 // both sides.

graph/db/models/channel_edge_info.go

@@ -304,6 +304,32 @@ func (c *ChannelEdgeInfo) FundingPKScript() ([]byte, error) {
 			return nil, err
 		}
 
+		if c.Features != nil && c.Features.HasFeature(
+			lnwire.SimpleTaprootChannelsOptionalStaging,
+		) {
+
+			pubKey1, err := btcec.ParsePubKey(btc1Key[:])
+			if err != nil {
+				return nil, err
+			}
+			pubKey2, err := btcec.ParsePubKey(btc2Key[:])
+			if err != nil {
+				return nil, err
+			}
+
+			fundingScript, _, err := input.GenTaprootFundingScript(
+				pubKey1, pubKey2, 0, c.MerkleRootHash,
+			)
+			if err != nil {
+				return nil, fmt.Errorf(
+					"unable to make taproot pkscript: %w",
+					err,
+				)
+			}
+
+			return fundingScript, nil
+		}
+
 		witnessScript, err := input.GenMultiSigScript(
 			btc1Key[:], btc2Key[:],
 		)

graph/db/models/channel_edge_info_test.go

@@ -145,3 +145,47 @@ func TestFundingPKScriptV2(t *testing.T) {
 		require.Equal(t, storedScript, pkScript)
 	})
 }
+
+// TestFundingPKScriptV1TaprootFeatureBit tests that a v1 channel edge carrying
+// the taproot staging bit reconstructs a taproot funding script.
+func TestFundingPKScriptV1TaprootFeatureBit(t *testing.T) {
+	t.Parallel()
+
+	privKey1, err := btcec.NewPrivateKey()
+	require.NoError(t, err)
+	pubKey1 := privKey1.PubKey()
+
+	privKey2, err := btcec.NewPrivateKey()
+	require.NoError(t, err)
+	pubKey2 := privKey2.PubKey()
+
+	var btcKey1, btcKey2 route.Vertex
+	copy(btcKey1[:], pubKey1.SerializeCompressed())
+	copy(btcKey2[:], pubKey2.SerializeCompressed())
+
+	// Build a v1 edge that only has the legacy bitcoin keys populated, but
+	// does advertise the taproot staging bit in its feature vector.
+	edge := &ChannelEdgeInfo{
+		Version:          lnwire.GossipVersion1,
+		BitcoinKey1Bytes: fn.Some(btcKey1),
+		BitcoinKey2Bytes: fn.Some(btcKey2),
+		Features: lnwire.NewFeatureVector(
+			lnwire.NewRawFeatureVector(
+				lnwire.SimpleTaprootChannelsRequiredStaging,
+			),
+			lnwire.Features,
+		),
+	}
+
+	pkScript, err := edge.FundingPKScript()
+	require.NoError(t, err)
+
+	// The fix should make FundingPKScript honor the feature bit and derive
+	// the taproot funding script directly from the stored bitcoin keys.
+	expectedScript, _, err := input.GenTaprootFundingScript(
+		pubKey1, pubKey2, 0, fn.None[chainhash.Hash](),
+	)
+	require.NoError(t, err)
+
+	require.Equal(t, expectedScript, pkScript)
+}

graph/db/sql_store.go

@@ -3054,7 +3054,8 @@ func (s *SQLStore) ChannelView(ctx context.Context,
 		switch v {
 		case gossipV1:
 			handleChannel := func(_ context.Context,
-				channel sqlc.ListChannelsPaginatedRow) error {
+				channel sqlc.ListChannelsPaginatedRow,
+				chanFeats map[int64][]int) error {
 
 				key1, err := route.NewVertexFromBytes(
 					channel.BitcoinKey1,
@@ -3070,11 +3071,28 @@ func (s *SQLStore) ChannelView(ctx context.Context,
 					return err
 				}
 
+				// Private taproot channels are currently stored
+				// as simple v1 channels that only need the
+				// taproot staging bit to reconstruct the BIP86
+				// funding script. They do not carry a custom
+				// tapscript root on this path.
+				//
+				// TODO: Remove this v1 feature-bit workaround
+				//  once private taproot channels have been
+				//  migrated to v2 gossip objects.
+				feats := lnwire.EmptyFeatureVector()
+				bits := chanFeats[channel.ID]
+				for _, bit := range bits {
+					feats.Set(lnwire.FeatureBit(bit))
+				}
+
 				edge := &models.ChannelEdgeInfo{
 					Version:          gossipV1,
 					BitcoinKey1Bytes: fn.Some(key1),
 					BitcoinKey2Bytes: fn.Some(key2),
+					Features:         feats,
 				}
+
 				pkScript, err := edge.FundingPKScript()
 				if err != nil {
 					return err
@@ -3114,9 +3132,25 @@ func (s *SQLStore) ChannelView(ctx context.Context,
 				return row.ID
 			}
 
-			return sqldb.ExecutePaginatedQuery(
+			collectID := func(
+				row sqlc.ListChannelsPaginatedRow) (int64,
+				error) {
+
+				return row.ID, nil
+			}
+
+			loadChannelFeatures := func(ctx context.Context,
+				chanIDs []int64) (map[int64][]int, error) {
+
+				return batchLoadChannelFeaturesHelper(
+					ctx, s.cfg.QueryCfg, db, chanIDs,
+				)
+			}
+
+			return sqldb.ExecuteCollectAndBatchWithSharedDataQuery(
 				ctx, s.cfg.QueryCfg, int64(-1), queryFunc,
-				extractCursor, handleChannel,
+				extractCursor, collectID, loadChannelFeatures,
+				handleChannel,
 			)
 
 		case gossipV2: