server: fix timestamp comparison in setSelfNode

Fix bug where setSelfNode compared only the seconds component of
timestamps instead of the full timestamp. This caused the node to
attempt persisting an older timestamp than what existed in the
database during restart, resulting in "sql: no rows in result set"
errors.

Author: ziggie1984

server.go

@@ -5556,6 +5556,16 @@ func (s *server) AttemptRBFCloseUpdate(ctx context.Context,
 	return updates, nil
 }
 
+// needsTimestampIncrement determines whether we need to increment the
+// timestamp for a node announcement to ensure it's at least one second after
+// the previously persisted timestamp. We compare at second precision to match
+// how timestamps are stored in the database (both SQL and KV stores truncate
+// to second precision). This ensures BOLT-07 compliance, which requires node
+// announcements to have strictly increasing timestamps.
+func needsTimestampIncrement(persistedTime, currentTime time.Time) bool {
+	return persistedTime.Unix() >= currentTime.Unix()
+}
+
 // setSelfNode configures and sets the server's self node. It sets the node
 // announcement, signs it, and updates the source node in the graph. When
 // determining values such as color and alias, the method prioritizes values
@@ -5623,7 +5633,7 @@ func (s *server) setSelfNode(ctx context.Context, nodePub route.Vertex,
 		// If we have a source node persisted in the DB already, then we
 		// just need to make sure that the new LastUpdate time is at
 		// least one second after the last update time.
-		if srcNode.LastUpdate.Second() >= nodeLastUpdate.Second() {
+		if needsTimestampIncrement(srcNode.LastUpdate, nodeLastUpdate) {
 			nodeLastUpdate = srcNode.LastUpdate.Add(time.Second)
 		}
 

server_test.go

@@ -0,0 +1,90 @@
+package lnd
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+// TestNodeAnnouncementTimestampComparison tests the timestamp comparison
+// logic used in setSelfNode to ensure node announcements have strictly
+// increasing timestamps at second precision (as required by BOLT-07 and
+// enforced by the database storage).
+func TestNodeAnnouncementTimestampComparison(t *testing.T) {
+	t.Parallel()
+
+	baseTime := int64(1700000000)
+
+	tests := []struct {
+		name              string
+		srcNodeLastUpdate time.Time
+		nodeLastUpdate    time.Time
+		shouldIncrement   bool
+		description       string
+	}{
+		{
+			name:              "same second different nanoseconds",
+			srcNodeLastUpdate: time.Unix(baseTime, 0),
+			nodeLastUpdate:    time.Unix(baseTime, 500_000_000),
+			shouldIncrement:   true,
+			description: "Edge case: timestamps in same second " +
+				"but different nanoseconds. Must increment " +
+				"to avoid persisting same second-level " +
+				"timestamp.",
+		},
+		{
+			name:              "different seconds",
+			srcNodeLastUpdate: time.Unix(baseTime, 0),
+			nodeLastUpdate:    time.Unix(baseTime+2, 0),
+			shouldIncrement:   false,
+			description: "Normal case: current time is already " +
+				"in a different (later) second. No increment " +
+				"needed.",
+		},
+		{
+			name:              "exactly equal",
+			srcNodeLastUpdate: time.Unix(baseTime, 123456789),
+			nodeLastUpdate:    time.Unix(baseTime, 123456789),
+			shouldIncrement:   true,
+			description: "Timestamps are identical. Must " +
+				"increment to ensure strictly greater " +
+				"timestamp.",
+		},
+		{
+			name:              "clock skew - persisted is newer",
+			srcNodeLastUpdate: time.Unix(baseTime+5, 0),
+			nodeLastUpdate:    time.Unix(baseTime+3, 0),
+			shouldIncrement:   true,
+			description: "Clock went backwards: persisted " +
+				"timestamp is newer than current time. Must " +
+				"increment from persisted timestamp.",
+		},
+		{
+			name:              "clock skew - same second",
+			srcNodeLastUpdate: time.Unix(baseTime+5, 100_000_000),
+			nodeLastUpdate:    time.Unix(baseTime+5, 900_000_000),
+			shouldIncrement:   true,
+			description: "Clock skew within same second. Must " +
+				"increment to ensure strictly greater " +
+				"second-level timestamp.",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			shouldIncrement := needsTimestampIncrement(
+				tc.srcNodeLastUpdate,
+				tc.nodeLastUpdate,
+			)
+
+			require.Equal(
+				t, tc.shouldIncrement, shouldIncrement,
+				"needsTimestampIncrement returned unexpected "+
+					"result: %s", tc.description,
+			)
+		})
+	}
+}