payments/db: remap legacy zero attempt IDs

Legacy KV payments can contain HTLC attempts with attempt ID zero. The
SQL payments schema requires payment_htlc_attempts.attempt_index to be
globally unique, so migrating multiple such attempts can fail with a
UNIQUE constraint violation.

Allocate synthetic attempt indexes for legacy zero-ID attempts from the
switch payment ID sequencer horizon. Keep nonzero attempt IDs unchanged
and advance the switch sequence once after migration validation succeeds.

This preserves the SQL uniqueness invariant and prevents future switch
IDs from colliding with migrated attempts. It also wraps HTLC insert
errors with the attempted index and payment hash so future migration
failures identify the problematic row.

Author: ziggie1984

payments/db/migration1/migration_validation.go

@@ -79,6 +79,20 @@ func validateMigratedPaymentBatch(ctx context.Context,
 					hash[:8], err)
 			}
 
+			if kvPayment.Status == StatusInFlight {
+				// Mirror the migration's legacy terminalization
+				// before comparing KV with SQL.
+				//
+				//nolint:ll
+				_, err = terminalizeUnresolvedLegacyZeroAttempts(
+					kvPayment,
+				)
+				if err != nil {
+					return fmt.Errorf("normalize KV "+
+						"payment %x: %w", hash[:8], err)
+				}
+			}
+
 			err = structuralCompare(kvPayment, row)
 			if err != nil {
 				// On structural mismatch, perform a deep
@@ -191,6 +205,16 @@ func deepComparePayment(ctx context.Context, cfg *SQLStoreConfig,
 			paymentHash[:8], err)
 	}
 
+	if kvPayment.Status == StatusInFlight {
+		// Mirror the migration's legacy terminalization before
+		// comparing KV with SQL.
+		_, err = terminalizeUnresolvedLegacyZeroAttempts(kvPayment)
+		if err != nil {
+			return fmt.Errorf("normalize KV payment %x: %w",
+				paymentHash[:8], err)
+		}
+	}
+	normalizeLegacyZeroAttemptIDsForCompare(kvPayment, sqlPayment)
 	normalizePaymentForCompare(kvPayment)
 	normalizePaymentForCompare(sqlPayment)
 
@@ -221,6 +245,60 @@ func deepComparePayment(ctx context.Context, cfg *SQLStoreConfig,
 	return nil
 }
 
+// normalizeLegacyZeroAttemptIDsForCompare aligns expected legacy attempt ID
+// remaps before deep comparison.
+//
+// Legacy KV payments can use attempt ID zero to represent an unknown ID. During
+// migration those attempts are assigned synthetic SQL attempt indexes, while
+// the source KV payment is left unchanged. Match by session key and copy the
+// SQL attempt ID into the KV object so fallback deep comparison still reports
+// real data mismatches instead of this expected migration repair.
+func normalizeLegacyZeroAttemptIDsForCompare(kvPayment,
+	sqlPayment *MPPayment) {
+
+	if kvPayment == nil || sqlPayment == nil {
+		return
+	}
+
+	sqlAttemptsBySessionKey := make(map[string]uint64)
+	for i := range sqlPayment.HTLCs {
+		htlc := &sqlPayment.HTLCs[i]
+		sessionKey := htlc.SessionKey()
+		if sessionKey == nil {
+			// Leave normalization incomplete so the deep comparison
+			// reports the malformed attempt instead of panicking.
+			continue
+		}
+
+		sessionKeyBytes := sessionKey.Serialize()
+		sessionKeyStr := string(sessionKeyBytes)
+		sqlAttemptsBySessionKey[sessionKeyStr] = htlc.AttemptID
+	}
+
+	for i := range kvPayment.HTLCs {
+		htlc := &kvPayment.HTLCs[i]
+		if htlc.AttemptID != 0 {
+			continue
+		}
+
+		sessionKey := htlc.SessionKey()
+		if sessionKey == nil {
+			// Leave normalization incomplete so the deep comparison
+			// reports the malformed attempt instead of panicking.
+			continue
+		}
+
+		sessionKeyBytes := sessionKey.Serialize()
+		sessionKeyStr := string(sessionKeyBytes)
+		attemptID, ok := sqlAttemptsBySessionKey[sessionKeyStr]
+		if !ok {
+			continue
+		}
+
+		htlc.AttemptID = attemptID
+	}
+}
+
 // normalizePaymentForCompare normalizes fields that are expected to differ
 // between KV and SQL representations before deep comparison.
 func normalizePaymentForCompare(payment *MPPayment) {