feat: add verify data root parameter to skip process proposal

blocksync/block_stats.go

@@ -0,0 +1,85 @@
+package blocksync
+
+import "slices"
+
+// blockStats is a circular blockSizes that holds at most n elements
+// and provides O(1) average calculation and O(1) max retrieval
+type blockStats struct {
+	blockSizes []int
+	capacity   int
+	size       int // current number of elements
+	head       int // index where the next element will be written
+	max        int // maximum value in the blockSizes
+}
+
+const defaultCapacity = 10
+
+// newBlockStats creates a new rotating blockSizes with given capacity
+func newBlockStats(capacity int) *blockStats {
+	if capacity <= 0 {
+		capacity = defaultCapacity
+	}
+	return &blockStats{
+		blockSizes: make([]int, capacity),
+		capacity:   capacity,
+		size:       0,
+		head:       0,
+	}
+}
+
+// Add adds a new element to the blockSizes
+// If the blockSizes is full, it removes the oldest element
+func (rb *blockStats) Add(value int) {
+	needRecalculateMax := false
+
+	if rb.size < rb.capacity {
+		rb.blockSizes[rb.head] = value
+		rb.size++
+
+		if rb.size == 1 || value > rb.max {
+			rb.max = value
+		}
+	} else {
+		// Buffer is full, replace the oldest element
+		oldValue := rb.blockSizes[rb.head]
+		rb.blockSizes[rb.head] = value
+
+		if oldValue == rb.max {
+			needRecalculateMax = true
+		} else if value > rb.max {
+			rb.max = value
+		}
+	}
+
+	rb.head = (rb.head + 1) % rb.capacity
+
+	if needRecalculateMax {
+		rb.recalculateMax()
+	}
+}
+
+// recalculateMax recalculates the maximum value by scanning the blockSizes
+// This is only called when the previous max value is removed
+func (rb *blockStats) recalculateMax() {
+	if rb.size == 0 {
+		rb.max = 0
+		return
+	}
+
+	rb.max = slices.Max(rb.blockSizes)
+}
+
+// GetMax returns the maximum value in the blockSizes
+func (rb *blockStats) GetMax() int {
+	return rb.max
+}
+
+// GetSize returns the current number of elements in the blockSizes
+func (rb *blockStats) GetSize() int {
+	return rb.size
+}
+
+// GetCapacity returns the maximum capacity of the blockSizes
+func (rb *blockStats) GetCapacity() int {
+	return rb.capacity
+}

blocksync/block_stats_test.go

@@ -0,0 +1,139 @@
+package blocksync
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewBlockStats(t *testing.T) {
+	t.Run("positive capacity", func(t *testing.T) {
+		rb := newBlockStats(5)
+		require.NotNil(t, rb)
+
+		assert.Equal(t, 5, rb.GetCapacity())
+		assert.Equal(t, 0, rb.GetSize())
+		assert.Equal(t, 0, rb.GetMax())
+	})
+
+	t.Run("non-positive capacity is default", func(t *testing.T) {
+		require.Equal(t, defaultCapacity, newBlockStats(0).capacity)
+		require.Equal(t, defaultCapacity, newBlockStats(-1).capacity)
+	})
+}
+
+func TestAddAndGetMax_BelowCapacity(t *testing.T) {
+	rb := newBlockStats(3)
+
+	t.Run("add first element", func(t *testing.T) {
+		rb.Add(5)
+		assert.Equal(t, 1, rb.GetSize())
+		assert.Equal(t, 3, rb.GetCapacity())
+		assert.Equal(t, 5, rb.GetMax())
+	})
+
+	t.Run("add smaller element", func(t *testing.T) {
+		rb.Add(3)
+		assert.Equal(t, 2, rb.GetSize())
+		assert.Equal(t, 5, rb.GetMax())
+	})
+
+	t.Run("add larger element", func(t *testing.T) {
+		rb.Add(10)
+		assert.Equal(t, 3, rb.GetSize())
+		assert.Equal(t, 10, rb.GetMax())
+	})
+}
+
+func TestAddAndGetMax_AtAndBeyondCapacity(t *testing.T) {
+	rb := newBlockStats(3)
+
+	// Fill to capacity: [5, 4, 3]
+	rb.Add(5)
+	rb.Add(4)
+	rb.Add(3)
+
+	assert.Equal(t, 3, rb.GetSize())
+	assert.Equal(t, 3, rb.GetCapacity())
+	assert.Equal(t, 5, rb.GetMax())
+
+	t.Run("overwrite non-max element", func(t *testing.T) {
+		// Current underlying slice indices (head == 0):
+		// [5, 4, 3]
+		// Overwrite index 0 (value 5) next, so we first overwrite a non-max
+		// by advancing head manually via add.
+		// To be precise: head is now 0 (next write), and oldValue is 5 (max).
+		// To test non-max overwrite, recreate a situation:
+		rb2 := newBlockStats(3)
+		rb2.Add(5) // [5, 0, 0] head=1, max=5
+		rb2.Add(4) // [5, 4, 0] head=2
+		rb2.Add(3) // [5, 4, 3] head=0
+
+		// Now overwrite index 0 with a *larger* value.
+		rb2.Add(6) // oldValue=5 (max), value=6 -> need recalc? no, value>max so max=6
+
+		assert.Equal(t, 3, rb2.GetCapacity())
+		assert.Equal(t, 3, rb2.GetSize())
+		assert.Equal(t, 6, rb2.GetMax())
+	})
+
+	t.Run("remove current max triggers recalculation", func(t *testing.T) {
+		rb3 := newBlockStats(3)
+
+		// [5, 4, 3], head=0, max=5
+		rb3.Add(5)
+		rb3.Add(4)
+		rb3.Add(3)
+
+		// Next Add overwrites index 0 (value 5, which is max).
+		// Use a value that is not larger than the remaining ones to force recalc.
+		rb3.Add(2) // now buffer is [2,4,3] in some rotation; max should be 4.
+
+		assert.Equal(t, 3, rb3.GetCapacity())
+		assert.Equal(t, 3, rb3.GetSize())
+		assert.Equal(t, 4, rb3.GetMax())
+	})
+
+	t.Run("max updates when new max added after recalc", func(t *testing.T) {
+		rb4 := newBlockStats(3)
+
+		// [5, 4, 3]
+		rb4.Add(5)
+		rb4.Add(4)
+		rb4.Add(3)
+
+		// Overwrite 5 with 2 -> recalc, max should become 4
+		rb4.Add(2)
+		assert.Equal(t, 3, rb4.GetCapacity())
+		assert.Equal(t, 3, rb4.GetSize())
+		assert.Equal(t, 4, rb4.GetMax())
+
+		// Now add a new bigger value, should update max immediately
+		rb4.Add(10)
+		assert.Equal(t, 3, rb4.GetCapacity())
+		assert.Equal(t, 3, rb4.GetSize())
+		assert.Equal(t, 10, rb4.GetMax())
+	})
+}
+
+func TestSizeNeverExceedsCapacity(t *testing.T) {
+	rb := newBlockStats(2)
+
+	rb.Add(1)
+	assert.Equal(t, 2, rb.GetCapacity())
+	assert.Equal(t, 1, rb.GetSize())
+
+	rb.Add(2)
+	assert.Equal(t, 2, rb.GetCapacity())
+	assert.Equal(t, 2, rb.GetSize())
+
+	// Now the buffer is full; further adds should keep size == capacity
+	rb.Add(3)
+	assert.Equal(t, 2, rb.GetCapacity())
+	assert.Equal(t, 2, rb.GetSize())
+
+	rb.Add(4)
+	assert.Equal(t, 2, rb.GetCapacity())
+	assert.Equal(t, 2, rb.GetSize())
+}