feat(evmreader): add multi binary search function

For f, x, count such that f(x) -> count.
MBSearch finds the xs where count changed.

To be used with GetNumberOfInputs with a block number specified in CallOpts

Author: mpolitzer

internal/evmreader/util.go

@@ -5,6 +5,7 @@ package evmreader
 
 import (
 	"cmp"
+	"fmt"
 	"slices"
 
 	. "github.com/cartesi/rollups-node/internal/model"
@@ -64,3 +65,52 @@ func indexApps[K comparable](
 	}
 	return result
 }
+
+// MBSearch is a multiple binary search over the function f.
+// It will find zero, one or multiple transition points x such that f(x-1) < f(x).
+// In addition, it will narrow the search space of subsequent points while probing f.
+// NOTE: This function assumes that f(0) == 0. In other words: that the transition
+// from 0 to 1 exists in the function image.
+func MBSearch(maxBlock uint64, f func(uint64) (uint64, error)) ([]uint64, error) {
+	max, err := f(maxBlock)
+	if err != nil {
+		return nil, fmt.Errorf("call failed with index %v: %w", maxBlock, err)
+	}
+	if max == 0 {
+		return nil, nil
+	}
+
+	low := make([]uint64, max+1)
+	high := make([]uint64, max+1)
+
+	for i := range max+1 {
+		low[i] = 0
+		high[i] = maxBlock
+	}
+
+	for end := max+1; end > 1; {
+		guess := (high[end-1] + low[end-1]) / 2
+		index, err := f(guess)
+
+		if err != nil {
+			return nil, fmt.Errorf("call failed with index %v: %w", guess, err)
+		}
+
+		for i := uint64(1); i < index+1; i++ {
+			if high[i] > guess {
+				high[i] = guess
+			}
+		}
+
+		for i := index+1; i < end; i++ {
+			if low[i] < guess {
+				low[i] = guess
+			}
+		}
+
+		if low[end-1]+1 == high[end-1] {
+			end--;
+		}
+	}
+	return high[1:], nil // discard the 0 entry.
+}

internal/evmreader/util_test.go

@@ -0,0 +1,46 @@
+// (c) Cartesi and individual authors (see AUTHORS)
+// SPDX-License-Identifier: Apache-2.0 (see LICENSE)
+
+package evmreader
+
+import (
+	"testing"
+	"github.com/stretchr/testify/assert"
+)
+
+func fN(xs []uint64)(func(uint64)(uint64,error)) {
+	return func(guess uint64)(uint64,error) {
+		for i,x := range xs {
+			if (x > guess) {
+				return uint64(i), nil
+			}
+		}
+		return uint64(len(xs)), nil
+	}
+}
+
+// test no values
+func TestMBSearch0(t *testing.T) {
+	result, err := MBSearch(1, fN([]uint64{}))
+	assert.Nil(t, err)
+	assert.Equal(t, 0, len(result))
+}
+
+// test a single values
+func TestMBSearch1(t *testing.T) {
+	result, err := MBSearch(4, fN([]uint64{1}))
+	assert.Nil(t, err)
+	assert.Equal(t, 1, len(result))
+	assert.Equal(t, uint64(1), result[0])
+}
+
+// test "many" values, including repeated ones.
+func TestMBSearch4(t *testing.T) {
+	result, err := MBSearch(1024, fN([]uint64{1, 100, 100, 1000}))
+	assert.Nil(t, err)
+	assert.Equal(t, 4, len(result))
+	assert.Equal(t, uint64(1), result[0])
+	assert.Equal(t, uint64(100), result[1])
+	assert.Equal(t, uint64(100), result[2])
+	assert.Equal(t, uint64(1000), result[3])
+}