Merge branch 'dev' into version-bump-v1.10.10

codec/hierarchycodec/codec_test.go

@@ -23,9 +23,7 @@ func TestMultipleTags(t *testing.T) {
 	}
 }
 
-func FuzzVectors(f *testing.F) {
-	for _, test := range codec.FuzzTests {
-		c := NewDefault()
-		test(c, f)
-	}
+func FuzzStructUnmarshalHierarchyCodec(f *testing.F) {
+	c := NewDefault()
+	codec.FuzzStructUnmarshal(c, f)
 }

codec/linearcodec/codec_test.go

@@ -23,9 +23,7 @@ func TestMultipleTags(t *testing.T) {
 	}
 }
 
-func FuzzVectors(f *testing.F) {
-	for _, test := range codec.FuzzTests {
-		c := NewDefault()
-		test(c, f)
-	}
+func FuzzStructUnmarshalLinearCodec(f *testing.F) {
+	c := NewDefault()
+	codec.FuzzStructUnmarshal(c, f)
 }

codec/test_codec.go

@@ -48,10 +48,6 @@ var (
 	MultipleTagsTests = []func(c GeneralCodec, t testing.TB){
 		TestMultipleTags,
 	}
-
-	FuzzTests = []func(c GeneralCodec, f *testing.F){
-		FuzzStructUnmarshal,
-	}
 )
 
 // The below structs and interfaces exist

database/corruptabledb/db_test.go

@@ -26,12 +26,16 @@ func TestInterface(t *testing.T) {
 	}
 }
 
-func FuzzInterface(f *testing.F) {
-	for _, test := range database.FuzzTests {
-		baseDB := memdb.New()
-		db := New(baseDB)
-		test(f, db)
-	}
+func FuzzKeyValue(f *testing.F) {
+	baseDB := memdb.New()
+	db := New(baseDB)
+	database.FuzzKeyValue(f, db)
+}
+
+func FuzzNewIteratorWithPrefix(f *testing.F) {
+	baseDB := memdb.New()
+	db := New(baseDB)
+	database.FuzzNewIteratorWithPrefix(f, db)
 }
 
 // TestCorruption tests to make sure corruptabledb wrapper works as expected.

database/encdb/db_test.go

@@ -24,15 +24,18 @@ func TestInterface(t *testing.T) {
 	}
 }
 
-func FuzzInterface(f *testing.F) {
-	for _, test := range database.FuzzTests {
-		unencryptedDB := memdb.New()
-		db, err := New([]byte(testPassword), unencryptedDB)
-		if err != nil {
-			require.NoError(f, err)
-		}
-		test(f, db)
-	}
+func FuzzKeyValue(f *testing.F) {
+	unencryptedDB := memdb.New()
+	db, err := New([]byte(testPassword), unencryptedDB)
+	require.NoError(f, err)
+	database.FuzzKeyValue(f, db)
+}
+
+func FuzzNewIteratorWithPrefix(f *testing.F) {
+	unencryptedDB := memdb.New()
+	db, err := New([]byte(testPassword), unencryptedDB)
+	require.NoError(f, err)
+	database.FuzzNewIteratorWithPrefix(f, db)
 }
 
 func BenchmarkInterface(b *testing.B) {

database/leveldb/db_test.go

@@ -20,32 +20,30 @@ func TestInterface(t *testing.T) {
 		db, err := New(folder, nil, logging.NoLog{}, "", prometheus.NewRegistry())
 		require.NoError(t, err)
 
-		defer db.Close()
-
 		test(t, db)
 
-		// The database may have been closed by the test, so we don't care if it
-		// errors here.
 		_ = db.Close()
 	}
 }
 
-func FuzzInterface(f *testing.F) {
-	for _, test := range database.FuzzTests {
-		folder := f.TempDir()
-		db, err := New(folder, nil, logging.NoLog{}, "", prometheus.NewRegistry())
-		if err != nil {
-			require.NoError(f, err)
-		}
+func FuzzKeyValue(f *testing.F) {
+	folder := f.TempDir()
+	db, err := New(folder, nil, logging.NoLog{}, "", prometheus.NewRegistry())
+	require.NoError(f, err)
+
+	defer db.Close()
 
-		defer db.Close()
+	database.FuzzKeyValue(f, db)
+}
 
-		test(f, db)
+func FuzzNewIteratorWithPrefix(f *testing.F) {
+	folder := f.TempDir()
+	db, err := New(folder, nil, logging.NoLog{}, "", prometheus.NewRegistry())
+	require.NoError(f, err)
 
-		// The database may have been closed by the test, so we don't care if it
-		// errors here.
-		_ = db.Close()
-	}
+	defer db.Close()
+
+	database.FuzzNewIteratorWithPrefix(f, db)
 }
 
 func BenchmarkInterface(b *testing.B) {

database/memdb/db_test.go

@@ -15,10 +15,12 @@ func TestInterface(t *testing.T) {
 	}
 }
 
-func FuzzInterface(f *testing.F) {
-	for _, test := range database.FuzzTests {
-		test(f, New())
-	}
+func FuzzKeyValue(f *testing.F) {
+	database.FuzzKeyValue(f, New())
+}
+
+func FuzzNewIteratorWithPrefix(f *testing.F) {
+	database.FuzzNewIteratorWithPrefix(f, New())
 }
 
 func BenchmarkInterface(b *testing.B) {

database/meterdb/db_test.go

@@ -24,15 +24,18 @@ func TestInterface(t *testing.T) {
 	}
 }
 
-func FuzzInterface(f *testing.F) {
-	for _, test := range database.FuzzTests {
-		baseDB := memdb.New()
-		db, err := New("", prometheus.NewRegistry(), baseDB)
-		if err != nil {
-			require.NoError(f, err)
-		}
-		test(f, db)
-	}
+func FuzzKeyValue(f *testing.F) {
+	baseDB := memdb.New()
+	db, err := New("", prometheus.NewRegistry(), baseDB)
+	require.NoError(f, err)
+	database.FuzzKeyValue(f, db)
+}
+
+func FuzzNewIteratorWithPrefix(f *testing.F) {
+	baseDB := memdb.New()
+	db, err := New("", prometheus.NewRegistry(), baseDB)
+	require.NoError(f, err)
+	database.FuzzNewIteratorWithPrefix(f, db)
 }
 
 func BenchmarkInterface(b *testing.B) {

database/prefixdb/db_test.go

@@ -22,10 +22,12 @@ func TestInterface(t *testing.T) {
 	}
 }
 
-func FuzzInterface(f *testing.F) {
-	for _, test := range database.FuzzTests {
-		test(f, New([]byte(""), memdb.New()))
-	}
+func FuzzKeyValue(f *testing.F) {
+	database.FuzzKeyValue(f, New([]byte(""), memdb.New()))
+}
+
+func FuzzNewIteratorWithPrefix(f *testing.F) {
+	database.FuzzNewIteratorWithPrefix(f, New([]byte(""), memdb.New()))
 }
 
 func BenchmarkInterface(b *testing.B) {

database/rpcdb/db_test.go

@@ -61,13 +61,18 @@ func TestInterface(t *testing.T) {
 	}
 }
 
-func FuzzInterface(f *testing.F) {
-	for _, test := range database.FuzzTests {
-		db := setupDB(f)
-		test(f, db.client)
+func FuzzKeyValue(f *testing.F) {
+	db := setupDB(f)
+	database.FuzzKeyValue(f, db.client)
 
-		db.closeFn()
-	}
+	db.closeFn()
+}
+
+func FuzzNewIteratorWithPrefix(f *testing.F) {
+	db := setupDB(f)
+	database.FuzzNewIteratorWithPrefix(f, db.client)
+
+	db.closeFn()
 }
 
 func BenchmarkInterface(b *testing.B) {

database/test_database.go

@@ -7,12 +7,14 @@ import (
 	"bytes"
 	"io"
 	"math"
+	"math/rand"
 	"testing"
 
 	"github.com/stretchr/testify/require"
 
 	"go.uber.org/mock/gomock"
 
+	"golang.org/x/exp/maps"
 	"golang.org/x/exp/slices"
 
 	"golang.org/x/sync/errgroup"
@@ -62,10 +64,6 @@ var Tests = []func(t *testing.T, db Database){
 	TestPutGetEmpty,
 }
 
-var FuzzTests = []func(*testing.F, Database){
-	FuzzKeyValue,
-}
-
 // TestSimpleKeyValue tests to make sure that simple Put + Get + Delete + Has
 // calls return the expected values.
 func TestSimpleKeyValue(t *testing.T, db Database) {
@@ -1203,3 +1201,66 @@ func FuzzKeyValue(f *testing.F, db Database) {
 		require.Equal(ErrNotFound, err)
 	})
 }
+
+func FuzzNewIteratorWithPrefix(f *testing.F, db Database) {
+	const (
+		maxKeyLen   = 32
+		maxValueLen = 32
+	)
+
+	f.Fuzz(func(
+		t *testing.T,
+		randSeed int64,
+		prefix []byte,
+		numKeyValues uint,
+	) {
+		require := require.New(t)
+		r := rand.New(rand.NewSource(randSeed)) // #nosec G404
+
+		// Put a bunch of key-values
+		expected := map[string][]byte{}
+		for i := 0; i < int(numKeyValues); i++ {
+			key := make([]byte, r.Intn(maxKeyLen))
+			_, _ = r.Read(key) // #nosec G404
+
+			value := make([]byte, r.Intn(maxValueLen))
+			_, _ = r.Read(value) // #nosec G404
+
+			if len(value) == 0 {
+				// Consistently treat zero length values as nil
+				// so that we can compare [expected] and [got] with
+				// require.Equal, which treats nil and empty byte
+				// as being unequal, whereas the database treats
+				// them as being equal.
+				value = nil
+			}
+
+			if bytes.HasPrefix(key, prefix) {
+				expected[string(key)] = value
+			}
+
+			require.NoError(db.Put(key, value))
+		}
+		expectedList := maps.Keys(expected)
+		slices.Sort(expectedList)
+
+		iter := db.NewIteratorWithPrefix(prefix)
+		defer iter.Release()
+
+		// Assert the iterator returns the expected key-values.
+		numIterElts := 0
+		for iter.Next() {
+			val := iter.Value()
+			if len(val) == 0 {
+				val = nil
+			}
+			require.Equal(expectedList[numIterElts], string(iter.Key()))
+			require.Equal(expected[string(iter.Key())], val)
+			numIterElts++
+		}
+		require.Equal(len(expectedList), numIterElts)
+
+		// Clear the database for the next fuzz iteration.
+		require.NoError(AtomicClear(db, db))
+	})
+}

database/versiondb/db_test.go

@@ -19,11 +19,12 @@ func TestInterface(t *testing.T) {
 	}
 }
 
-func FuzzInterface(f *testing.F) {
-	for _, test := range database.FuzzTests {
-		baseDB := memdb.New()
-		test(f, New(baseDB))
-	}
+func FuzzKeyValue(f *testing.F) {
+	database.FuzzKeyValue(f, New(memdb.New()))
+}
+
+func FuzzNewIteratorWithPrefix(f *testing.F) {
+	database.FuzzNewIteratorWithPrefix(f, New(memdb.New()))
 }
 
 func TestIterate(t *testing.T) {

scripts/mocks.mockgen.txt

@@ -26,7 +26,7 @@ github.com/ava-labs/avalanchego/utils/filesystem=Reader=utils/filesystem/mock_io
 github.com/ava-labs/avalanchego/utils/hashing=Hasher=utils/hashing/mock_hasher.go
 github.com/ava-labs/avalanchego/utils/logging=Logger=utils/logging/mock_logger.go
 github.com/ava-labs/avalanchego/utils/resource=User=utils/resource/mock_user.go
-github.com/ava-labs/avalanchego/vms/avm/blocks=Block=vms/avm/blocks/mock_block.go
+github.com/ava-labs/avalanchego/vms/avm/block=Block=vms/avm/block/mock_block.go
 github.com/ava-labs/avalanchego/vms/avm/metrics=Metrics=vms/avm/metrics/mock_metrics.go
 github.com/ava-labs/avalanchego/vms/avm/states=Chain,State,Diff=vms/avm/states/mock_states.go
 github.com/ava-labs/avalanchego/vms/avm/txs/mempool=Mempool=vms/avm/txs/mempool/mock_mempool.go

snow/consensus/snowman/poll/early_term_no_traversal.go

@@ -51,14 +51,26 @@ func (p *earlyTermNoTraversalPoll) Drop(vdr ids.NodeID) {
 	p.polled.Remove(vdr)
 }
 
-// Finished returns true when all validators have voted
+// Finished returns true when one of the following conditions is met.
+//
+//  1. There are no outstanding votes.
+//  2. It is impossible for the poll to achieve an alpha majority after applying
+//     transitive voting.
+//  3. A single element has achieved an alpha majority.
 func (p *earlyTermNoTraversalPoll) Finished() bool {
 	remaining := p.polled.Len()
+	if remaining == 0 {
+		return true // Case 1
+	}
+
 	received := p.votes.Len()
+	maxPossibleVotes := received + remaining
+	if maxPossibleVotes < p.alpha {
+		return true // Case 2
+	}
+
 	_, freq := p.votes.Mode()
-	return remaining == 0 || // All k nodes responded
-		freq >= p.alpha || // An alpha majority has returned
-		received+remaining < p.alpha // An alpha majority can never return
+	return freq >= p.alpha // Case 3
 }
 
 // Result returns the result of this poll