Adjust find next key alt approach

x/merkledb/codec.go

@@ -489,7 +489,7 @@ func (c *codecImpl) decodeDBNode(b []byte, n *dbNode) (uint16, error) {
 			return 0, err
 		}
 		n.children[byte(index)] = child{
-			compressedPath: compressedPath.deserialize(),
+			compressedPath: compressedPath.Deserialize(),
 			id:             childID,
 		}
 	}

x/merkledb/codec_test.go

@@ -46,7 +46,7 @@ func newRandomProofNode(r *rand.Rand) ProofNode {
 	}
 
 	return ProofNode{
-		KeyPath:     newPath(key).Serialize(),
+		KeyPath:     NewPath(key).Serialize(),
 		ValueOrHash: Some(val),
 		Children:    children,
 	}
@@ -199,7 +199,7 @@ func FuzzCodecSerializedPath(f *testing.F) {
 			require.Len(bufBytes, numRead)
 			require.Equal(b[:numRead], bufBytes)
 
-			clonedGot := got.deserialize().Serialize()
+			clonedGot := got.Deserialize().Serialize()
 			require.Equal(got, clonedGot)
 		},
 	)
@@ -527,7 +527,7 @@ func FuzzCodecDBNodeDeterministic(f *testing.F) {
 				_, _ = r.Read(childPathBytes)              // #nosec G404
 
 				children[byte(i)] = child{
-					compressedPath: newPath(childPathBytes),
+					compressedPath: NewPath(childPathBytes),
 					id:             childID,
 				}
 			}

x/merkledb/db.go

@@ -84,7 +84,7 @@ type Database struct {
 	metadataDB database.Database
 
 	// If a value is nil, the corresponding key isn't in the trie.
-	nodeCache     onEvictCache[path, *node]
+	nodeCache     onEvictCache[Path, *node]
 	onEvictionErr utils.Atomic[error]
 
 	// Stores change lists. Used to serve change proofs and construct
@@ -122,7 +122,7 @@ func newDatabase(
 
 	// Note: trieDB.OnEviction is responsible for writing intermediary nodes to
 	// disk as they are evicted from the cache.
-	trieDB.nodeCache = newOnEvictCache[path](config.NodeCacheSize, trieDB.onEviction)
+	trieDB.nodeCache = newOnEvictCache[Path](config.NodeCacheSize, trieDB.onEviction)
 
 	root, err := trieDB.initializeRootIfNeeded()
 	if err != nil {
@@ -132,8 +132,8 @@ func newDatabase(
 	// add current root to history (has no changes)
 	trieDB.history.record(&changeSummary{
 		rootID: root,
-		values: map[path]*change[Maybe[[]byte]]{},
-		nodes:  map[path]*change[*node]{},
+		values: map[Path]*change[Maybe[[]byte]]{},
+		nodes:  map[Path]*change[*node]{},
 	})
 
 	shutdownType, err := trieDB.metadataDB.Get(cleanShutdownKey)
@@ -190,7 +190,7 @@ func (db *Database) rebuild(ctx context.Context) error {
 		}
 
 		key := it.Key()
-		path := path(key)
+		path := Path(key)
 		value := it.Value()
 		n, err := parseNode(path, value)
 		if err != nil {
@@ -327,7 +327,7 @@ func (db *Database) GetValues(ctx context.Context, keys [][]byte) ([][]byte, []e
 	values := make([][]byte, len(keys))
 	errors := make([]error, len(keys))
 	for i, key := range keys {
-		values[i], errors[i] = db.getValueCopy(newPath(key), false /*lock*/)
+		values[i], errors[i] = db.getValueCopy(NewPath(key), false /*lock*/)
 	}
 	return values, errors
 }
@@ -338,12 +338,12 @@ func (db *Database) GetValue(ctx context.Context, key []byte) ([]byte, error) {
 	_, span := db.tracer.Start(ctx, "MerkleDB.GetValue")
 	defer span.End()
 
-	return db.getValueCopy(newPath(key), true /*lock*/)
+	return db.getValueCopy(NewPath(key), true /*lock*/)
 }
 
 // getValueCopy returns a copy of the value for the given [key].
 // Returns database.ErrNotFound if it doesn't exist.
-func (db *Database) getValueCopy(key path, lock bool) ([]byte, error) {
+func (db *Database) getValueCopy(key Path, lock bool) ([]byte, error) {
 	val, err := db.getValue(key, lock)
 	if err != nil {
 		return nil, err
@@ -355,7 +355,7 @@ func (db *Database) getValueCopy(key path, lock bool) ([]byte, error) {
 // Returns database.ErrNotFound if it doesn't exist.
 // If [lock], [db.lock]'s read lock is acquired.
 // Otherwise assumes [db.lock] is already held.
-func (db *Database) getValue(key path, lock bool) ([]byte, error) {
+func (db *Database) getValue(key Path, lock bool) ([]byte, error) {
 	if lock {
 		db.lock.RLock()
 		defer db.lock.RUnlock()
@@ -511,7 +511,7 @@ func (db *Database) GetChangeProof(
 	// values modified between [startRootID] to [endRootID] sorted in increasing
 	// order.
 	changedKeys := maps.Keys(changes.values)
-	slices.SortFunc(changedKeys, func(i, j path) bool {
+	slices.SortFunc(changedKeys, func(i, j Path) bool {
 		return i.Compare(j) < 0
 	})
 
@@ -620,7 +620,7 @@ func (db *Database) Has(k []byte) (bool, error) {
 		return false, database.ErrClosed
 	}
 
-	_, err := db.getValue(newPath(k), false /*lock*/)
+	_, err := db.getValue(NewPath(k), false /*lock*/)
 	if err == database.ErrNotFound {
 		return false, nil
 	}
@@ -671,21 +671,21 @@ func (db *Database) NewIterator() database.Iterator {
 
 func (db *Database) NewIteratorWithStart(start []byte) database.Iterator {
 	return &iterator{
-		nodeIter: db.nodeDB.NewIteratorWithStart(newPath(start).Bytes()),
+		nodeIter: db.nodeDB.NewIteratorWithStart(NewPath(start).Bytes()),
 		db:       db,
 	}
 }
 
 func (db *Database) NewIteratorWithPrefix(prefix []byte) database.Iterator {
 	return &iterator{
-		nodeIter: db.nodeDB.NewIteratorWithPrefix(newPath(prefix).Bytes()),
+		nodeIter: db.nodeDB.NewIteratorWithPrefix(NewPath(prefix).Bytes()),
 		db:       db,
 	}
 }
 
 func (db *Database) NewIteratorWithStartAndPrefix(start, prefix []byte) database.Iterator {
-	startBytes := newPath(start).Bytes()
-	prefixBytes := newPath(prefix).Bytes()
+	startBytes := NewPath(start).Bytes()
+	prefixBytes := NewPath(prefix).Bytes()
 	return &iterator{
 		nodeIter: db.nodeDB.NewIteratorWithStartAndPrefix(startBytes, prefixBytes),
 		db:       db,
@@ -992,7 +992,7 @@ func (db *Database) getKeysNotInSet(start, end []byte, keySet set.Set[string]) (
 // This copy may be edited by the caller without affecting the database state.
 // Returns database.ErrNotFound if the node doesn't exist.
 // Assumes [db.lock] isn't held.
-func (db *Database) getEditableNode(key path) (*node, error) {
+func (db *Database) getEditableNode(key Path) (*node, error) {
 	db.lock.RLock()
 	defer db.lock.RUnlock()
 
@@ -1007,7 +1007,7 @@ func (db *Database) getEditableNode(key path) (*node, error) {
 // Editing the returned node affects the database state.
 // Returns database.ErrNotFound if the node doesn't exist.
 // Assumes [db.lock] is read locked.
-func (db *Database) getNode(key path) (*node, error) {
+func (db *Database) getNode(key Path) (*node, error) {
 	if db.closed {
 		return nil, database.ErrClosed
 	}
@@ -1175,14 +1175,14 @@ func (db *Database) prepareRangeProofView(start []byte, proof *RangeProof) (*tri
 }
 
 // Non-nil error is fatal -- [db] will close.
-func (db *Database) putNodeInCache(key path, n *node) error {
+func (db *Database) putNodeInCache(key Path, n *node) error {
 	// TODO Cache metrics
 	// Note that this may cause a node to be evicted from the cache,
 	// which will call [OnEviction].
 	return db.nodeCache.Put(key, n)
 }
 
-func (db *Database) getNodeInCache(key path) (*node, bool) {
+func (db *Database) getNodeInCache(key Path) (*node, bool) {
 	// TODO Cache metrics
 	if node, ok := db.nodeCache.Get(key); ok {
 		return node, true

x/merkledb/db_test.go

@@ -33,7 +33,7 @@ func Test_MerkleDB_Get_Safety(t *testing.T) {
 
 	val, err := db.Get([]byte{0})
 	require.NoError(t, err)
-	n, err := db.getNode(newPath([]byte{0}))
+	n, err := db.getNode(NewPath([]byte{0}))
 	require.NoError(t, err)
 	val[0] = 1
 
@@ -762,10 +762,10 @@ func runRandDBTest(require *require.Assertions, r *rand.Rand, rt randTest) {
 	startRoot, err := db.GetMerkleRoot(context.Background())
 	require.NoError(err)
 
-	values := make(map[path][]byte) // tracks content of the trie
+	values := make(map[Path][]byte) // tracks content of the trie
 	currentBatch := db.NewBatch()
-	currentValues := make(map[path][]byte)
-	deleteValues := make(map[path]struct{})
+	currentValues := make(map[Path][]byte)
+	deleteValues := make(map[Path]struct{})
 	pastRoots := []ids.ID{}
 
 	for i, step := range rt {
@@ -774,13 +774,13 @@ func runRandDBTest(require *require.Assertions, r *rand.Rand, rt randTest) {
 		case opUpdate:
 			err := currentBatch.Put(step.key, step.value)
 			require.NoError(err)
-			currentValues[newPath(step.key)] = step.value
-			delete(deleteValues, newPath(step.key))
+			currentValues[NewPath(step.key)] = step.value
+			delete(deleteValues, NewPath(step.key))
 		case opDelete:
 			err := currentBatch.Delete(step.key)
 			require.NoError(err)
-			deleteValues[newPath(step.key)] = struct{}{}
-			delete(currentValues, newPath(step.key))
+			deleteValues[NewPath(step.key)] = struct{}{}
+			delete(currentValues, NewPath(step.key))
 		case opGenerateRangeProof:
 			root, err := db.GetMerkleRoot(context.Background())
 			require.NoError(err)
@@ -843,15 +843,15 @@ func runRandDBTest(require *require.Assertions, r *rand.Rand, rt randTest) {
 					pastRoots = pastRoots[len(pastRoots)-300:]
 				}
 			}
-			currentValues = map[path][]byte{}
-			deleteValues = map[path]struct{}{}
+			currentValues = map[Path][]byte{}
+			deleteValues = map[Path]struct{}{}
 			currentBatch = db.NewBatch()
 		case opGet:
 			v, err := db.Get(step.key)
 			if err != nil {
 				require.ErrorIs(err, database.ErrNotFound)
 			}
-			want := values[newPath(step.key)]
+			want := values[NewPath(step.key)]
 			require.True(bytes.Equal(want, v)) // Use bytes.Equal so nil treated equal to []byte{}
 			trieValue, err := getNodeValue(db, string(step.key))
 			if err != nil {

x/merkledb/history.go

@@ -53,15 +53,15 @@ type changeSummaryAndIndex struct {
 type changeSummary struct {
 	rootID ids.ID
 	// key is path prefix
-	nodes map[path]*change[*node]
+	nodes map[Path]*change[*node]
 	// key is full path
-	values map[path]*change[Maybe[[]byte]]
+	values map[Path]*change[Maybe[[]byte]]
 }
 
 func newChangeSummary(estimatedSize int) *changeSummary {
 	return &changeSummary{
-		nodes:  make(map[path]*change[*node], estimatedSize),
-		values: make(map[path]*change[Maybe[[]byte]], estimatedSize),
+		nodes:  make(map[Path]*change[*node], estimatedSize),
+		values: make(map[Path]*change[Maybe[[]byte]], estimatedSize),
 	}
 }
 
@@ -128,13 +128,13 @@ func (th *trieHistory) getValueChanges(startRoot, endRoot ids.ID, start, end []b
 	// Keep changes sorted so the largest can be removed in order to stay within the maxLength limit.
 	sortedKeys := btree.NewG(
 		2,
-		func(a, b path) bool {
+		func(a, b Path) bool {
 			return a.Compare(b) < 0
 		},
 	)
 
-	startPath := newPath(start)
-	endPath := newPath(end)
+	startPath := NewPath(start)
+	endPath := NewPath(end)
 
 	// For each element in the history in the range between [startRoot]'s
 	// last appearance (exclusive) and [endRoot]'s last appearance (inclusive),
@@ -206,8 +206,8 @@ func (th *trieHistory) getChangesToGetToRoot(rootID ids.ID, start, end []byte) (
 	}
 
 	var (
-		startPath       = newPath(start)
-		endPath         = newPath(end)
+		startPath       = NewPath(start)
+		endPath         = NewPath(end)
 		combinedChanges = newChangeSummary(defaultPreallocationSize)
 	)
 

x/merkledb/history_test.go

@@ -361,10 +361,10 @@ func Test_History_Values_Lookup_Over_Queue_Break(t *testing.T) {
 	// changes should still be collectable even though the history has had to loop due to hitting max size
 	changes, err := db.history.getValueChanges(startRoot, endRoot, nil, nil, 10)
 	require.NoError(err)
-	require.Contains(changes.values, newPath([]byte("key1")))
-	require.Equal([]byte("value1"), changes.values[newPath([]byte("key1"))].after.value)
-	require.Contains(changes.values, newPath([]byte("key2")))
-	require.Equal([]byte("value3"), changes.values[newPath([]byte("key2"))].after.value)
+	require.Contains(changes.values, NewPath([]byte("key1")))
+	require.Equal([]byte("value1"), changes.values[NewPath([]byte("key1"))].after.value)
+	require.Contains(changes.values, NewPath([]byte("key2")))
+	require.Equal([]byte("value3"), changes.values[NewPath([]byte("key2"))].after.value)
 }
 
 func Test_History_RepeatedRoot(t *testing.T) {
@@ -770,14 +770,14 @@ func TestHistoryGetChangesToRoot(t *testing.T) {
 	for i := 0; i < maxHistoryLen; i++ { // Fill the history
 		changes = append(changes, &changeSummary{
 			rootID: ids.GenerateTestID(),
-			nodes: map[path]*change[*node]{
-				newPath([]byte{byte(i)}): {
+			nodes: map[Path]*change[*node]{
+				NewPath([]byte{byte(i)}): {
 					before: &node{id: ids.GenerateTestID()},
 					after:  &node{id: ids.GenerateTestID()},
 				},
 			},
-			values: map[path]*change[Maybe[[]byte]]{
-				newPath([]byte{byte(i)}): {
+			values: map[Path]*change[Maybe[[]byte]]{
+				NewPath([]byte{byte(i)}): {
 					before: Some([]byte{byte(i)}),
 					after:  Some([]byte{byte(i + 1)}),
 				},
@@ -816,7 +816,7 @@ func TestHistoryGetChangesToRoot(t *testing.T) {
 				require.Len(got.nodes, 1)
 				require.Len(got.values, 1)
 				reversedChanges := changes[maxHistoryLen-1]
-				removedKey := newPath([]byte{byte(maxHistoryLen - 1)})
+				removedKey := NewPath([]byte{byte(maxHistoryLen - 1)})
 				require.Equal(reversedChanges.nodes[removedKey].before, got.nodes[removedKey].after)
 				require.Equal(reversedChanges.values[removedKey].before, got.values[removedKey].after)
 				require.Equal(reversedChanges.values[removedKey].after, got.values[removedKey].before)
@@ -829,12 +829,12 @@ func TestHistoryGetChangesToRoot(t *testing.T) {
 				require.Len(got.nodes, 2)
 				require.Len(got.values, 2)
 				reversedChanges1 := changes[maxHistoryLen-1]
-				removedKey1 := newPath([]byte{byte(maxHistoryLen - 1)})
+				removedKey1 := NewPath([]byte{byte(maxHistoryLen - 1)})
 				require.Equal(reversedChanges1.nodes[removedKey1].before, got.nodes[removedKey1].after)
 				require.Equal(reversedChanges1.values[removedKey1].before, got.values[removedKey1].after)
 				require.Equal(reversedChanges1.values[removedKey1].after, got.values[removedKey1].before)
 				reversedChanges2 := changes[maxHistoryLen-2]
-				removedKey2 := newPath([]byte{byte(maxHistoryLen - 2)})
+				removedKey2 := NewPath([]byte{byte(maxHistoryLen - 2)})
 				require.Equal(reversedChanges2.nodes[removedKey2].before, got.nodes[removedKey2].after)
 				require.Equal(reversedChanges2.values[removedKey2].before, got.values[removedKey2].after)
 				require.Equal(reversedChanges2.values[removedKey2].after, got.values[removedKey2].before)
@@ -848,12 +848,12 @@ func TestHistoryGetChangesToRoot(t *testing.T) {
 				require.Len(got.nodes, 2)
 				require.Len(got.values, 1)
 				reversedChanges1 := changes[maxHistoryLen-1]
-				removedKey1 := newPath([]byte{byte(maxHistoryLen - 1)})
+				removedKey1 := NewPath([]byte{byte(maxHistoryLen - 1)})
 				require.Equal(reversedChanges1.nodes[removedKey1].before, got.nodes[removedKey1].after)
 				require.Equal(reversedChanges1.values[removedKey1].before, got.values[removedKey1].after)
 				require.Equal(reversedChanges1.values[removedKey1].after, got.values[removedKey1].before)
 				reversedChanges2 := changes[maxHistoryLen-2]
-				removedKey2 := newPath([]byte{byte(maxHistoryLen - 2)})
+				removedKey2 := NewPath([]byte{byte(maxHistoryLen - 2)})
 				require.Equal(reversedChanges2.nodes[removedKey2].before, got.nodes[removedKey2].after)
 			},
 		},
@@ -865,10 +865,10 @@ func TestHistoryGetChangesToRoot(t *testing.T) {
 				require.Len(got.nodes, 2)
 				require.Len(got.values, 1)
 				reversedChanges1 := changes[maxHistoryLen-1]
-				removedKey1 := newPath([]byte{byte(maxHistoryLen - 1)})
+				removedKey1 := NewPath([]byte{byte(maxHistoryLen - 1)})
 				require.Equal(reversedChanges1.nodes[removedKey1].before, got.nodes[removedKey1].after)
 				reversedChanges2 := changes[maxHistoryLen-2]
-				removedKey2 := newPath([]byte{byte(maxHistoryLen - 2)})
+				removedKey2 := NewPath([]byte{byte(maxHistoryLen - 2)})
 				require.Equal(reversedChanges2.nodes[removedKey2].before, got.nodes[removedKey2].after)
 				require.Equal(reversedChanges2.values[removedKey2].before, got.values[removedKey2].after)
 				require.Equal(reversedChanges2.values[removedKey2].after, got.values[removedKey2].before)

x/merkledb/iterator.go

@@ -42,7 +42,7 @@ func (i *iterator) Next() bool {
 	}
 	for i.nodeIter.Next() {
 		i.db.metrics.IOKeyRead()
-		n, err := parseNode(path(i.nodeIter.Key()), i.nodeIter.Value())
+		n, err := parseNode(Path(i.nodeIter.Key()), i.nodeIter.Value())
 		if err != nil {
 			i.err = err
 			return false

x/merkledb/maybe.go

@@ -3,7 +3,9 @@
 
 package merkledb
 
-import "golang.org/x/exp/slices"
+import (
+	"golang.org/x/exp/slices"
+)
 
 // Maybe T = Some T | Nothing.
 // A data wrapper that allows values to be something [Some T] or nothing [Nothing].