peer: make the final cooperative close update cancellable

Send the final close update through a helper that also observes the request
context and peer shutdown. Remove the channel closer afterward regardless of
whether the update was delivered.

Add regression tests covering request cancellation and peer shutdown.

Author: ziggie1984

peer/brontide.go

@@ -3931,6 +3931,24 @@ func ChooseAddr(addr lnwire.DeliveryAddress) fn.Option[lnwire.DeliveryAddress] {
 	return fn.Some(addr)
 }
 
+// sendFinalCloseUpdate notifies the close caller that its transaction has
+// confirmed. The caller may have stopped reading its bounded update channel,
+// so cancellation of either the request or peer must always release this send.
+func sendFinalCloseUpdate(closeReq *htlcswitch.ChanClose,
+	closingTxid chainhash.Hash, peerQuit <-chan struct{}) {
+
+	select {
+	case closeReq.Updates <- &ChannelCloseUpdate{
+		ClosingTxid: closingTxid[:],
+		Success:     true,
+	}:
+
+	case <-closeReq.Ctx.Done():
+
+	case <-peerQuit:
+	}
+}
+
 // observeRbfCloseUpdates observes the channel for any updates that may
 // indicate that a new txid has been broadcasted, or the channel fully closed
 // on chain.
@@ -4055,10 +4073,14 @@ func (p *Brontide) observeRbfCloseUpdates(chanCloser *chancloser.RbfChanCloser,
 				// update to the client.
 				closingTxid := closeState.ConfirmedTx.TxHash()
 				if closeReq != nil {
-					closeReq.Updates <- &ChannelCloseUpdate{
-						ClosingTxid: closingTxid[:],
-						Success:     true,
-					}
+					// Updates is bounded. The caller may no
+					// longer be reading. Stop waiting when
+					// the request or peer shuts down, so
+					// cleanup can proceed.
+					sendFinalCloseUpdate(
+						closeReq, closingTxid,
+						p.cg.Done(),
+					)
 				}
 				chanID := lnwire.NewChanIDFromOutPoint(
 					*closeReq.ChanPoint,

peer/brontide_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcutil/v2"
 	"github.com/btcsuite/btcd/chaincfg/v2"
+	"github.com/btcsuite/btcd/chainhash/v2"
 	"github.com/btcsuite/btcd/txscript/v2"
 	"github.com/btcsuite/btcd/wire/v2"
 	"github.com/lightningnetwork/lnd/chainntnfs"
@@ -1585,6 +1586,70 @@ func TestReadHandlerPanicRecovery(t *testing.T) {
 	}
 }
 
+// TestCloseFinNotificationUnblocks asserts that a full client update channel
+// cannot hold peer teardown open after either the request or peer is canceled.
+func TestCloseFinNotificationUnblocks(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name         string
+		shutdownPeer bool
+	}{
+		{
+			name: "request canceled",
+		},
+		{
+			name:         "peer stopped",
+			shutdownPeer: true,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+
+			ctx, cancel := context.WithCancel(t.Context())
+			defer cancel()
+			updates := make(chan interface{}, 1)
+			updates <- struct{}{}
+			peerQuit := make(chan struct{})
+			closeReq := &htlcswitch.ChanClose{
+				Updates: updates,
+				Ctx:     ctx,
+			}
+
+			done := make(chan struct{})
+			go func() {
+				defer close(done)
+
+				sendFinalCloseUpdate(
+					closeReq, chainhash.Hash{}, peerQuit,
+				)
+			}()
+
+			select {
+			case <-done:
+				t.Fatal("notification returned while no exit " +
+					"condition was ready")
+			case <-time.After(50 * time.Millisecond):
+			}
+
+			if test.shutdownPeer {
+				close(peerQuit)
+			} else {
+				cancel()
+			}
+
+			select {
+			case <-done:
+			case <-time.After(timeout):
+				t.Fatal("final close notification blocked " +
+					"teardown")
+			}
+		})
+	}
+}
+
 // TestMessageSummaryPingIncludesNumPongBytes ensures the debug summary for a
 // ping exposes the requested pong size, which makes ignored no-reply pings
 // visible without requiring trace-level logging.