lnwallet: add comprehensive tests for LocalNonces sync

Adds extensive test coverage for the new LocalNonces functionality in
channel synchronization, ensuring both legacy and new nonce fields work
correctly together.

Test additions include:
- Helper function to extract nonces from either LocalNonces or LocalNonce
- Comprehensive TestChanSyncTaprootLocalNonces covering all scenarios
- Tests for backwards compatibility when only one field is present
- Error handling tests for missing nonce scenarios
- Updates to existing sync tests to handle both nonce field types

Author: Roasbeef

lnwallet/channel_test.go

@@ -3073,6 +3073,25 @@ func TestAddHTLCNegativeBalance(t *testing.T) {
 // assertNoChanSyncNeeded is a helper function that asserts that upon restart,
 // two channels conclude that they're fully synchronized and don't need to
 // retransmit any new messages.
+// extractCommitmentNonce extracts the commitment nonce from a ChannelReestablish
+// message, prioritizing LocalNonces over the legacy LocalNonce field.
+func extractCommitmentNonce(t *testing.T, msg *lnwire.ChannelReestablish) lnwire.Musig2Nonce {
+	// Prefer LocalNonces if present
+	if msg.LocalNonces.IsSome() {
+		noncesData := msg.LocalNonces.UnwrapOrFail(t)
+
+		// Return the first nonce (for main commitment)
+		for _, nonce := range noncesData.NoncesMap {
+			return nonce
+		}
+
+		// If map is empty, fall back to LocalNonce
+	}
+
+	// Fall back to legacy LocalNonce field
+	return msg.LocalNonce.UnwrapOrFailV(t)
+}
+
 func assertNoChanSyncNeeded(t *testing.T, aliceChannel *LightningChannel,
 	bobChannel *LightningChannel) {
 
@@ -3090,13 +3109,14 @@ func assertNoChanSyncNeeded(t *testing.T, aliceChannel *LightningChannel,
 	}
 
 	// For taproot channels, simulate the link/peer binding the generated
-	// nonces.
+	// nonces. Use helper to extract nonces from either LocalNonces or
+	// LocalNonce.
 	if aliceChannel.channelState.ChanType.IsTaproot() {
 		aliceChannel.pendingVerificationNonce = &musig2.Nonces{
-			PubNonce: aliceChanSyncMsg.LocalNonce.UnwrapOrFailV(t),
+			PubNonce: extractCommitmentNonce(t, aliceChanSyncMsg),
 		}
 		bobChannel.pendingVerificationNonce = &musig2.Nonces{
-			PubNonce: bobChanSyncMsg.LocalNonce.UnwrapOrFailV(t),
+			PubNonce: extractCommitmentNonce(t, bobChanSyncMsg),
 		}
 	}
 
@@ -3538,6 +3558,71 @@ func testChanSyncOweCommitment(t *testing.T, chanType channeldb.ChannelType) {
 	}
 }
 
+// TestChanSyncTaprootLocalNonces tests that for taproot channels, both the
+// legacy LocalNonce field and the new LocalNonces field are populated in
+// ChannelReestablish messages, and that the receiving side can handle either.
+func TestChanSyncTaprootLocalNonces(t *testing.T) {
+	t.Parallel()
+
+	// Create a taproot test channel.
+	chanType := channeldb.SimpleTaprootFeatureBit
+	aliceChannel, bobChannel, err := CreateTestChannels(t, chanType)
+	require.NoError(t, err, "unable to create test channels")
+
+	// Both sides should be fully synced from the start.
+	assertNoChanSyncNeeded(t, aliceChannel, bobChannel)
+
+	// Generate ChannelReestablish messages.
+	aliceChanSyncMsg, err := aliceChannel.channelState.ChanSyncMsg()
+	require.NoError(t, err, "unable to produce chan sync msg")
+	bobChanSyncMsg, err := bobChannel.channelState.ChanSyncMsg()
+	require.NoError(t, err, "unable to produce chan sync msg")
+
+	// For taproot channels, both LocalNonce and LocalNonces should be populated.
+	require.True(t, aliceChanSyncMsg.LocalNonce.IsSome(), "LocalNonce should be set")
+	require.True(t, aliceChanSyncMsg.LocalNonces.IsSome(), "LocalNonces should be set")
+	require.True(t, bobChanSyncMsg.LocalNonce.IsSome(), "LocalNonce should be set")
+	require.True(t, bobChanSyncMsg.LocalNonces.IsSome(), "LocalNonces should be set")
+
+	// The nonces from both fields should be identical.
+	aliceLegacyNonce := aliceChanSyncMsg.LocalNonce.UnwrapOrFailV(t)
+	aliceNoncesData := aliceChanSyncMsg.LocalNonces.UnwrapOrFail(t)
+	require.Len(t, aliceNoncesData.NoncesMap, 1, "should have exactly one nonce")
+	var aliceMapNonce lnwire.Musig2Nonce
+	for _, nonce := range aliceNoncesData.NoncesMap {
+		aliceMapNonce = nonce
+		break
+	}
+	require.Equal(t, aliceLegacyNonce, aliceMapNonce, "nonces should match")
+
+	// Test that our helper function works correctly.
+	extractedNonce := extractCommitmentNonce(t, aliceChanSyncMsg)
+	require.Equal(t, aliceLegacyNonce, extractedNonce, "helper should extract correct nonce")
+
+	// Test sync behavior when only LocalNonces is present by clearing LocalNonce.
+	aliceModifiedMsg := *aliceChanSyncMsg
+	aliceModifiedMsg.LocalNonce = lnwire.OptMusig2NonceTLV{}
+
+	// Bob should still be able to process the message with only LocalNonces.
+	bobChannel.pendingVerificationNonce = &musig2.Nonces{
+		PubNonce: extractCommitmentNonce(t, bobChanSyncMsg),
+	}
+	bobMsgsToSend, _, _, err := bobChannel.ProcessChanSyncMsg(
+		ctxb, &aliceModifiedMsg,
+	)
+	require.NoError(t, err, "unable to process modified ChannelReestablish msg")
+	require.Empty(t, bobMsgsToSend, "bob shouldn't need to send messages")
+
+	// Test that missing both fields results in an error.
+	aliceEmptyMsg := *aliceChanSyncMsg
+	aliceEmptyMsg.LocalNonce = lnwire.OptMusig2NonceTLV{}
+	aliceEmptyMsg.LocalNonces = lnwire.OptLocalNonces{}
+
+	_, _, _, err = bobChannel.ProcessChanSyncMsg(ctxb, &aliceEmptyMsg)
+	require.Error(t, err, "should error when no nonce is provided")
+	require.Contains(t, err.Error(), "remote verification nonce not sent")
+}
+
 // TestChanSyncOweCommitment tests that if Bob restarts (and then Alice) before
 // he receives Alice's CommitSig message, then Alice concludes that she needs
 // to re-send the CommitDiff. After the diff has been sent, both nodes should