Fixes bug where HotArchive buckets ommited by Buckets() (#5856)

Author: SirTyson

historyarchive/history_archive_state.go

@@ -57,10 +57,10 @@ type HistoryArchiveState struct {
 	HotArchiveBuckets BucketList `json:"hotArchiveBuckets"`
 }
 
-func (h *HistoryArchiveState) LevelSummary() (string, int, error) {
+func summarizeBucketList(buckets BucketList) (string, int, error) {
 	summ := ""
 	nz := 0
-	for _, b := range h.CurrentBuckets {
+	for _, b := range buckets {
 		state := '_'
 		for _, bs := range []string{
 			b.Curr, b.Snap, b.Next.Output,
@@ -87,26 +87,66 @@ func (h *HistoryArchiveState) LevelSummary() (string, int, error) {
 	return summ, nz, nil
 }
 
-func (h *HistoryArchiveState) Buckets() ([]Hash, error) {
-	r := []Hash{}
-	for _, b := range h.CurrentBuckets {
-		for _, bs := range []string{
-			b.Curr, b.Snap, b.Next.Output,
-		} {
+func (h *HistoryArchiveState) LevelSummary() (string, int, error) {
+	currentSummary, currentNz, err := summarizeBucketList(h.CurrentBuckets)
+	if err != nil {
+		return "", 0, err
+	}
+
+	// For V2+, include hot archive buckets
+	if h.Version >= HistoryArchiveStateVersionForProtocol23 {
+		hotSummary, hotNz, err := summarizeBucketList(h.HotArchiveBuckets)
+		if err != nil {
+			return "", 0, err
+		}
+		return currentSummary + "|" + hotSummary, currentNz + hotNz, nil
+	}
+
+	return currentSummary, currentNz, nil
+}
+
+func extractBucketHashes(buckets BucketList) ([]Hash, error) {
+	var result []Hash
+	for _, b := range buckets {
+		for _, bs := range []string{b.Curr, b.Snap, b.Next.Output} {
 			// Ignore empty values
 			if bs == "" {
 				continue
 			}
 
 			h, err := DecodeHash(bs)
 			if err != nil {
-				return r, err
+				return result, err
 			}
 			if !h.IsZero() {
-				r = append(r, h)
+				result = append(result, h)
 			}
 		}
 	}
+	return result, nil
+}
+
+// Returns all Buckets reference by the HistoryArchiveState. This includes
+// both the live Buckets and hot archive Buckets (for HAS version 2+).
+func (h *HistoryArchiveState) Buckets() ([]Hash, error) {
+	r := []Hash{}
+
+	// Extract current buckets
+	currentBuckets, err := extractBucketHashes(h.CurrentBuckets)
+	if err != nil {
+		return r, err
+	}
+	r = append(r, currentBuckets...)
+
+	// Include hot archive buckets for version 2+ (protocol 23+)
+	if h.Version >= HistoryArchiveStateVersionForProtocol23 {
+		hotArchiveBuckets, err := extractBucketHashes(h.HotArchiveBuckets)
+		if err != nil {
+			return r, err
+		}
+		r = append(r, hotArchiveBuckets...)
+	}
+
 	return r, nil
 }
 

historyarchive/history_archive_state_test.go

@@ -81,3 +81,60 @@ func TestHashValidation(t *testing.T) {
 		})
 	}
 }
+
+func countBuckets(buckets BucketList) int {
+	count := 0
+	for _, level := range buckets {
+		for _, bs := range []string{level.Curr, level.Snap, level.Next.Output} {
+			if bs != "" && bs != "0000000000000000000000000000000000000000000000000000000000000000" {
+				count++
+			}
+		}
+	}
+	return count
+}
+
+func TestBucketsIncludesHotArchiveBuckets(t *testing.T) {
+	for _, testCase := range []struct {
+		inputFile       string
+		expectedVersion int
+	}{
+		{
+			inputFile:       "testdata/historyV1.json",
+			expectedVersion: 1,
+		},
+		{
+			inputFile:       "testdata/historyV2.json",
+			expectedVersion: HistoryArchiveStateVersionForProtocol23,
+		},
+	} {
+		t.Run(testCase.inputFile, func(t *testing.T) {
+			inputBytes, err := os.ReadFile(testCase.inputFile)
+			require.NoError(t, err)
+
+			var state HistoryArchiveState
+			require.NoError(t, json.Unmarshal(inputBytes, &state))
+
+			// Verify the version
+			assert.Equal(t, testCase.expectedVersion, state.Version)
+
+			// Verify that the Buckets() method includes hot archive buckets for V2
+			buckets, err := state.Buckets()
+			require.NoError(t, err)
+
+			currentBucketCount := countBuckets(state.CurrentBuckets)
+			hotArchiveBucketCount := countBuckets(state.HotArchiveBuckets)
+
+			if testCase.expectedVersion >= HistoryArchiveStateVersionForProtocol23 {
+				expectedTotal := currentBucketCount + hotArchiveBucketCount
+				assert.Equal(t, expectedTotal, len(buckets),
+					"Buckets() should include both currentBuckets and hotArchiveBuckets for V2+")
+			} else {
+				assert.Equal(t, 0, hotArchiveBucketCount,
+					"V1 should have 0 hot archive buckets")
+				assert.Equal(t, currentBucketCount, len(buckets),
+					"Buckets() should only include currentBuckets for V1")
+			}
+		})
+	}
+}

historyarchive/testdata/historyV2.json

@@ -176,7 +176,7 @@
       "curr": "ae7e4814b50e176d8e3532e462e2e9db02f218adebd74603d7e349cc19f489e2",
       "next": {
         "state": 1,
-        "output": "50abed8a9d86c072cfe8388246b7a378dc355fe996fd7384a5ee57e8da2ad52"
+        "output": "50abed8a9d86c072cfe8388246b7a378dc355fe996fd7384a5ee57e8da2ad520"
       },
       "snap": "0000000000000000000000000000000000000000000000000000000000000000"
     }