multi: reduce remaining alert noise

chainbackends/lndclient_adapters.go

@@ -2,6 +2,7 @@ package chainbackends
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"log/slog"
 	"time"
@@ -15,6 +16,8 @@ import (
 	"github.com/lightningnetwork/lnd/chainntnfs"
 	fn "github.com/lightningnetwork/lnd/fn/v2"
 	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 )
 
 // lndRegistrationTimeout bounds how long a conf/spend registration call into
@@ -27,6 +30,19 @@ import (
 // genuinely wedged backend surfaces as an error rather than a silent hang.
 const lndRegistrationTimeout = 15 * time.Second
 
+// isBlockEpochShutdownError reports whether an LND call only failed because
+// the owning block-epoch subscription is shutting down. The context check is
+// required so an independent Canceled status from a live backend remains an
+// actionable warning.
+func isBlockEpochShutdownError(ctx context.Context, err error) bool {
+	if ctx.Err() == nil {
+		return false
+	}
+
+	return errors.Is(err, context.Canceled) ||
+		status.Code(err) == codes.Canceled
+}
+
 // LndClientTxBroadcaster implements TxBroadcaster using
 // lndclient.WalletKitClient.
 type LndClientTxBroadcaster struct {
@@ -507,6 +523,20 @@ func (n *LndClientChainNotifier) RegisterBlockEpochNtfn(
 					ctx, int64(height),
 				)
 				if err != nil {
+					if isBlockEpochShutdownError(ctx, err) {
+						log.DebugS(ctx, "Block hash "+
+							"lookup cancelled during "+
+							"subscription shutdown",
+							slog.Any("err", err),
+							slog.Int(
+								"height",
+								int(height),
+							),
+						)
+
+						continue
+					}
+
 					log.WarnS(
 						ctx,
 						"Failed to get block hash",
@@ -535,7 +565,18 @@ func (n *LndClientChainNotifier) RegisterBlockEpochNtfn(
 
 			case err, ok := <-errChan:
 				if ok && err != nil {
-					log.WarnS(ctx, "Block epoch error", err)
+					if isBlockEpochShutdownError(ctx, err) {
+						log.DebugS(ctx, "Block epoch "+
+							"subscription cancelled",
+							slog.Any("err", err),
+						)
+					} else {
+						log.WarnS(
+							ctx,
+							"Block epoch error",
+							err,
+						)
+					}
 				}
 
 				return

chainbackends/lndclient_adapters_test.go

@@ -11,8 +11,65 @@ import (
 	"github.com/lightninglabs/lndclient"
 	"github.com/lightningnetwork/lnd/chainntnfs"
 	"github.com/stretchr/testify/require"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 )
 
+// TestIsBlockEpochShutdownError pins the classification boundary between an
+// expected subscription shutdown and an actionable live-backend failure.
+func TestIsBlockEpochShutdownError(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name          string
+		cancelContext bool
+		err           error
+		want          bool
+	}{
+		{
+			name: "live backend canceled status",
+			err:  status.Error(codes.Canceled, "backend canceled"),
+		},
+		{
+			name:          "owning context canceled",
+			cancelContext: true,
+			err:           context.Canceled,
+			want:          true,
+		},
+		{
+			name:          "shutdown canceled status",
+			cancelContext: true,
+			err: status.Error(
+				codes.Canceled, "subscription closed",
+			),
+			want: true,
+		},
+		{
+			name:          "unrelated shutdown error",
+			cancelContext: true,
+			err:           errors.New("backend unavailable"),
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+
+			ctx := t.Context()
+			if test.cancelContext {
+				var cancel context.CancelFunc
+				ctx, cancel = context.WithCancel(ctx)
+				cancel()
+			}
+
+			require.Equal(
+				t, test.want,
+				isBlockEpochShutdownError(ctx, test.err),
+			)
+		})
+	}
+}
+
 // stubLndClientNotifier exposes controllable lndclient notification streams.
 type stubLndClientNotifier struct {
 	lndclient.ChainNotifierClient

round/actor.go

@@ -2333,8 +2333,10 @@ func (a *RoundClientActor) handleGetState(ctx context.Context,
 	for keyStr, roundFSM := range a.rounds {
 		roundState, err := fsmState(scanCtx, roundFSM.FSM)
 		if err != nil {
-			a.log.WarnS(ctx, "Failed to get FSM state for round",
-				err,
+			a.log.DebugS(
+				ctx,
+				"Skipped round with unreadable FSM state",
+				slog.Any("err", err),
 				slog.String("key", string(keyStr)),
 			)
 
@@ -2923,12 +2925,13 @@ func (a *RoundClientActor) processOutbox(ctx context.Context,
 				inputSigState.CommitmentTx,
 			)
 
-			// Index for confirmation routing and register.
+			// Index the transaction before the confirmation request
+			// emitted by the FSM can be delivered. The FSM outbox
+			// owns the steady-state registration; registering again
+			// here creates two notifier subscriptions for the same
+			// tx. A restarted actor still re-registers active
+			// rounds in Start.
 			a.commitmentTxIndex[txid] = keyStr
-			a.registerCommitmentConfirmation(
-				ctx, txid, roundFSM.CommitmentTx,
-				inputSigState.VTXOTreePaths,
-			)
 
 			a.log.InfoS(ctx, "Round checkpoint processed",
 				slog.String("round_id", m.RoundID.String()),

round/actor_test.go

@@ -835,8 +835,20 @@ func TestActorProcessOutbox(t *testing.T) {
 		// Set up a round in InputSigSentState, simulating the state
 		// after the round has completed through partial sigs.
 		commitmentTx := h.setupRoundInInputSigSentState(roundID)
+		txid := commitmentTx.UnsignedTx.TxHash()
+		pkScript := confirmationWatchScript(
+			commitmentTx.UnsignedTx, nil,
+		)
+		targetConfs := h.actor.env.OperatorTerms.MinConfirmations
 
 		outbox := []ClientOutMsg{
+			&RegisterConfirmationRequest{
+				CallerID:    "commitment-" + txid.String(),
+				Txid:        &txid,
+				PkScript:    pkScript,
+				TargetConfs: targetConfs,
+				HeightHint:  h.actor.env.StartHeight,
+			},
 			&RoundCheckpointedNotification{
 				RoundID: roundID,
 			},
@@ -850,10 +862,18 @@ func TestActorProcessOutbox(t *testing.T) {
 		keyStr := RoundKeyStr(roundID.KeyString())
 		require.Contains(t, h.actor.rounds, keyStr)
 
-		txid := commitmentTx.UnsignedTx.TxHash()
 		indexedKeyStr, exists := h.actor.commitmentTxIndex[txid]
 		require.True(t, exists)
 		require.Equal(t, keyStr, indexedKeyStr)
+
+		// The FSM outbox registration is sufficient. Processing the
+		// checkpoint notification must not create a second notifier for
+		// the same commitment transaction.
+		require.Len(t, h.chainSource.registrations, 1)
+		registration := h.chainSource.registrations[0]
+		require.True(t, registration.Txid.IsEqual(&txid))
+		require.Equal(t, pkScript, registration.PkScript)
+		require.Equal(t, targetConfs, registration.TargetConfs)
 	})
 
 	t.Run("new_boarding_creates_round", func(t *testing.T) {

round/transitions.go

@@ -3097,6 +3097,9 @@ func confirmationWatchScript(commitmentTx *wire.MsgTx,
 	return commitmentTx.TxOut[idx].PkScript
 }
 
+// forfeitCollectionOutbox orders the reconciliation timeout before every
+// fallible external effect, then preserves the server submission sequence
+// before registering the commitment confirmation watch.
 func (s *ForfeitSignaturesCollectingState) forfeitCollectionOutbox(
 	env *ClientEnvironment,
 	forfeitTxs map[wire.OutPoint]*types.ForfeitTxSig,
@@ -3115,17 +3118,6 @@ func (s *ForfeitSignaturesCollectingState) forfeitCollectionOutbox(
 			RoundKey: RoundKeyStr(s.RoundID.KeyString()),
 			Phase:    TimeoutPhaseForfeitCollection,
 		},
-		&SubmitVTXOForfeitSigsToServer{
-			RoundID:    s.RoundID,
-			ForfeitTxs: forfeitTxs,
-		},
-		&RegisterConfirmationRequest{
-			CallerID:    callerID,
-			Txid:        &txid,
-			PkScript:    pkScript,
-			TargetConfs: env.OperatorTerms.MinConfirmations,
-			HeightHint:  env.StartHeight,
-		},
 	}
 
 	// The forfeit signatures leave the box on this transition, opening the
@@ -3144,18 +3136,28 @@ func (s *ForfeitSignaturesCollectingState) forfeitCollectionOutbox(
 		})
 	}
 
-	if len(boardingInputSigs) == 0 {
-		return outboxMsgs
+	// The timeout must be armed before either fallible external effect.
+	// processOutbox stops on the first error, so placing it after the
+	// signature submission or chain registration could strand the round in
+	// forfeit collection with no reconciliation path.
+	outboxMsgs = append(outboxMsgs, &SubmitVTXOForfeitSigsToServer{
+		RoundID:    s.RoundID,
+		ForfeitTxs: forfeitTxs,
+	})
+	if len(boardingInputSigs) > 0 {
+		outboxMsgs = append(outboxMsgs, &SubmitForfeitSigRequest{
+			RoundID:    s.RoundID,
+			Signatures: boardingInputSigs,
+		})
 	}
 
-	return append(
-		outboxMsgs[:2], append([]ClientOutMsg{
-			&SubmitForfeitSigRequest{
-				RoundID:    s.RoundID,
-				Signatures: boardingInputSigs,
-			},
-		}, outboxMsgs[2:]...)...,
-	)
+	return append(outboxMsgs, &RegisterConfirmationRequest{
+		CallerID:    callerID,
+		Txid:        &txid,
+		PkScript:    pkScript,
+		TargetConfs: env.OperatorTerms.MinConfirmations,
+		HeightHint:  env.StartHeight,
+	})
 }
 
 func (s *ForfeitSignaturesCollectingState) checkpointRound(

round/vtxo_tree_binding_test.go

@@ -2,8 +2,10 @@ package round
 
 import (
 	"testing"
+	"time"
 
 	"github.com/btcsuite/btcd/chainhash/v2"
+	"github.com/btcsuite/btcd/psbt/v2"
 	"github.com/btcsuite/btcd/txscript/v2"
 	"github.com/btcsuite/btcd/wire/v2"
 	"github.com/lightninglabs/wavelength/lib/tree"
@@ -254,6 +256,50 @@ func TestConfirmationWatchScriptUsesBatchOutput(t *testing.T) {
 	watch := confirmationWatchScript(tx, trees)
 	require.Equal(t, batchScript, watch)
 	require.NotEqual(t, fillerScript, watch)
+
+	// The real FSM outbox must carry the same validated script and
+	// operator confirmation target. This is the sole steady-state watch;
+	// restart recovery independently rebuilds the same parameters.
+	packet, err := psbt.NewFromUnsignedTx(tx)
+	require.NoError(t, err)
+	state := &ForfeitSignaturesCollectingState{
+		RoundID:       testRoundIDTr("nonzero-batch-output"),
+		CommitmentTx:  packet,
+		VTXOTreePaths: trees,
+		Intents: Intents{
+			Forfeits: []types.ForfeitRequest{
+				{},
+			},
+		},
+	}
+	const targetConfs = 6
+	const startHeight = 123
+	outbox := state.forfeitCollectionOutbox(
+		&ClientEnvironment{
+			OperatorTerms: &types.OperatorTerms{
+				MinConfirmations: targetConfs,
+			},
+			StartHeight:            startHeight,
+			StatusReconcileTimeout: time.Minute,
+		},
+		nil, []*types.BoardingInputSignature{{}},
+	)
+
+	// Keep the timeout ahead of every fallible effect while preserving the
+	// server submission order: VTXO forfeits, boarding signatures, and then
+	// chain registration. This must not depend on an insertion index whose
+	// meaning changes when another outbox message is added.
+	require.Len(t, outbox, 5)
+	require.IsType(t, &CancelTimeoutReq{}, outbox[0])
+	require.IsType(t, &StartTimeoutReq{}, outbox[1])
+	require.IsType(t, &SubmitVTXOForfeitSigsToServer{}, outbox[2])
+	require.IsType(t, &SubmitForfeitSigRequest{}, outbox[3])
+	registration, ok := outbox[4].(*RegisterConfirmationRequest)
+	require.True(t, ok)
+	require.Equal(t, batchScript, registration.PkScript)
+	require.Equal(t, uint32(targetConfs), registration.TargetConfs)
+	require.Equal(t, uint32(startHeight), registration.HeightHint)
+	require.True(t, registration.Txid.IsEqual(&txid))
 }
 
 // TestCommitmentTxReceivedRejectsUnboundTree confirms the binding is wired into