multi: wire taproot RBF support throughout the stack

In this commit we, integrate the taproot RBF cooperative close
functionality throughout the LND stack. This includes updating
protocol configuration and peer connection handling to support
the new taproot closing flow.

The changes wire through the taproot channel detection, nonce
exchange during shutdown, and proper handling of the enhanced
wire protocol messages in the peer layer. This completes the
integration of taproot RBF cooperative close functionality,
providing a complete alternate closing path for taproot channels
that leverages MuSig2 signatures and implements proper nonce
rotation for secure RBF scenarios.

Author: Roasbeef

lncfg/protocol.go

@@ -37,7 +37,7 @@ type ProtocolOptions struct {
 
 	// RbfCoopClose should be set if we want to signal that we support for
 	// the new experimental RBF coop close feature.
-	RbfCoopClose bool `long:"rbf-coop-close" description:"if set, then lnd will signal that it supports the new RBF based coop close protocol, taproot channels are not supported"`
+	RbfCoopClose bool `long:"rbf-coop-close" description:"if set, then lnd will signal that it supports the new RBF based coop close protocol"`
 
 	// NoAnchors should be set if we don't want to support opening or accepting
 	// channels having the anchor commitment type.

peer/brontide.go

@@ -1243,17 +1243,15 @@ func (p *Brontide) loadActiveChannels(chans []*channeldb.OpenChannel) (
 			return nil, err
 		}
 
-		isTaprootChan := lnChan.ChanType().IsTaproot()
 
 		var (
 			shutdownMsg     fn.Option[lnwire.Shutdown]
 			shutdownInfoErr error
 		)
 		shutdownInfo.WhenSome(func(info channeldb.ShutdownInfo) {
 			// If we can use the new RBF close feature, we don't
-			// need to create the legacy closer. However for taproot
-			// channels, we'll continue to use the legacy closer.
-			if p.rbfCoopCloseAllowed() && !isTaprootChan {
+			// need to create the legacy closer.
+			if p.rbfCoopCloseAllowed() {
 				return
 			}
 
@@ -1330,10 +1328,8 @@ func (p *Brontide) loadActiveChannels(chans []*channeldb.OpenChannel) (
 		p.activeChannels.Store(chanID, lnChan)
 
 		// We're using the old co-op close, so we don't need to init
-		// the new RBF chan closer. If we have a taproot chan, then
-		// we'll also use the legacy type, so we don't need to make the
-		// new closer.
-		if !p.rbfCoopCloseAllowed() || isTaprootChan {
+		// the new RBF chan closer.
+		if !p.rbfCoopCloseAllowed() {
 			continue
 		}
 
@@ -3312,7 +3308,6 @@ func chooseDeliveryScript(upfront, requested lnwire.DeliveryAddress,
 func (p *Brontide) restartCoopClose(lnChan *lnwallet.LightningChannel) (
 	*lnwire.Shutdown, error) {
 
-	isTaprootChan := lnChan.ChanType().IsTaproot()
 
 	// If this channel has status ChanStatusCoopBroadcasted and does not
 	// have a closing transaction, then the cooperative close process was
@@ -3366,8 +3361,8 @@ func (p *Brontide) restartCoopClose(lnChan *lnwallet.LightningChannel) (
 
 	// If the new RBF co-op close is negotiated, then we'll init and start
 	// that state machine, skipping the steps for the negotiate machine
-	// below. We don't support this close type for taproot channels though.
-	if p.rbfCoopCloseAllowed() && !isTaprootChan {
+	// below.
+	if p.rbfCoopCloseAllowed() {
 		_, err := p.initRbfChanCloser(lnChan)
 		if err != nil {
 			return nil, fmt.Errorf("unable to init rbf chan "+
@@ -3910,6 +3905,14 @@ func (p *Brontide) initRbfChanCloser(
 		),
 	}
 
+	// For taproot channels, we need to set both LocalMusigSession and 
+	// RemoteMusigSession to handle nonce exchange during RBF cooperative close.
+	if channel.ChanType().IsTaproot() {
+		musigCloser := NewMusigChanCloser(channel)
+		env.LocalMusigSession = musigCloser
+		env.RemoteMusigSession = musigCloser
+	}
+
 	spendEvent := protofsm.RegisterSpend[chancloser.ProtocolEvent]{
 		OutPoint:   channel.ChannelPoint(),
 		PkScript:   channel.FundingTxOut().PkScript,
@@ -4221,7 +4224,6 @@ func (p *Brontide) handleLocalCloseReq(req *htlcswitch.ChanClose) {
 		return
 	}
 
-	isTaprootChan := channel.ChanType().IsTaproot()
 
 	switch req.CloseType {
 	// A type of CloseRegular indicates that the user has opted to close
@@ -4235,9 +4237,7 @@ func (p *Brontide) handleLocalCloseReq(req *htlcswitch.ChanClose) {
 		// iteration, in which case we'll be obtaining a new
 		// transaction w/ a higher fee rate.
 		//
-		// We don't support this close type for taproot channels yet
-		// however.
-		case !isTaprootChan && p.rbfCoopCloseAllowed():
+		case p.rbfCoopCloseAllowed():
 			err = p.startRbfChanCloser(
 				newRPCShutdownInit(req), channel.ChannelPoint(),
 			)
@@ -5196,12 +5196,10 @@ func (p *Brontide) addActiveChannel(c *lnpeer.NewChannel) error {
 			"peer", chanPoint)
 	}
 
-	isTaprootChan := c.ChanType.IsTaproot()
 
 	// We're using the old co-op close, so we don't need to init the new RBF
-	// chan closer. If this is a taproot channel, then we'll also fall
-	// through, as we don't support this type yet w/ rbf close.
-	if !p.rbfCoopCloseAllowed() || isTaprootChan {
+	// chan closer.
+	if !p.rbfCoopCloseAllowed() {
 		return nil
 	}