Clean up merkleDB interface and duplicate code

x/merkledb/db.go

@@ -449,13 +449,8 @@ func (db *merkleDB) PrefetchPaths(keys [][]byte) error {
 		return database.ErrClosed
 	}
 
-	// reuse the view so that it can keep repeated nodes in memory
-	tempView, err := newTrieView(db, db, ViewChanges{})
-	if err != nil {
-		return err
-	}
 	for _, key := range keys {
-		if err := db.prefetchPath(tempView, key); err != nil {
+		if err := db.prefetchPath(key); err != nil {
 			return err
 		}
 	}
@@ -470,16 +465,11 @@ func (db *merkleDB) PrefetchPath(key []byte) error {
 	if db.closed {
 		return database.ErrClosed
 	}
-	tempView, err := newTrieView(db, db, ViewChanges{})
-	if err != nil {
-		return err
-	}
-
-	return db.prefetchPath(tempView, key)
+	return db.prefetchPath(key)
 }
 
-func (db *merkleDB) prefetchPath(view *trieView, keyBytes []byte) error {
-	return view.visitPathToKey(ToKey(keyBytes), func(n *node) error {
+func (db *merkleDB) prefetchPath(keyBytes []byte) error {
+	return visitPathToKey(db, ToKey(keyBytes), func(n *node) error {
 		if !n.hasValue() {
 			return db.intermediateNodeDB.nodeCache.Put(n.key, n)
 		}
@@ -583,33 +573,13 @@ func (db *merkleDB) getMerkleRoot() ids.ID {
 	return db.rootID
 }
 
-// isSentinelNodeTheRoot returns true if the passed in sentinel node has a value and or multiple child nodes
-// When this is true, the root of the trie is the sentinel node
-// When this is false, the root of the trie is the sentinel node's single child
-func isSentinelNodeTheRoot(sentinel *node) bool {
-	return sentinel.valueDigest.HasValue() || len(sentinel.children) != 1
-}
-
 func (db *merkleDB) GetProof(ctx context.Context, key []byte) (*Proof, error) {
 	db.commitLock.RLock()
 	defer db.commitLock.RUnlock()
 
-	return db.getProof(ctx, key)
-}
-
-// Assumes [db.commitLock] is read locked.
-// Assumes [db.lock] is not held
-func (db *merkleDB) getProof(ctx context.Context, key []byte) (*Proof, error) {
-	if db.closed {
-		return nil, database.ErrClosed
-	}
-
-	view, err := newTrieView(db, db, ViewChanges{})
-	if err != nil {
-		return nil, err
-	}
-	// Don't need to lock [view] because nobody else has a reference to it.
-	return view.getProof(ctx, key)
+	_, span := db.infoTracer.Start(ctx, "MerkleDB.GetProof")
+	defer span.End()
+	return getProof(db, key)
 }
 
 func (db *merkleDB) GetRangeProof(
@@ -618,10 +588,7 @@ func (db *merkleDB) GetRangeProof(
 	end maybe.Maybe[[]byte],
 	maxLength int,
 ) (*RangeProof, error) {
-	db.commitLock.RLock()
-	defer db.commitLock.RUnlock()
-
-	return db.getRangeProofAtRoot(ctx, db.getMerkleRoot(), start, end, maxLength)
+	return db.GetRangeProofAtRoot(ctx, db.getMerkleRoot(), start, end, maxLength)
 }
 
 func (db *merkleDB) GetRangeProofAtRoot(
@@ -634,30 +601,21 @@ func (db *merkleDB) GetRangeProofAtRoot(
 	db.commitLock.RLock()
 	defer db.commitLock.RUnlock()
 
-	return db.getRangeProofAtRoot(ctx, rootID, start, end, maxLength)
-}
+	_, span := db.infoTracer.Start(ctx, "MerkleDB.GetRangeProofAtRoot")
+	defer span.End()
 
-// Assumes [db.commitLock] is read locked.
-// Assumes [db.lock] is not held
-func (db *merkleDB) getRangeProofAtRoot(
-	ctx context.Context,
-	rootID ids.ID,
-	start maybe.Maybe[[]byte],
-	end maybe.Maybe[[]byte],
-	maxLength int,
-) (*RangeProof, error) {
 	if db.closed {
 		return nil, database.ErrClosed
 	}
 	if maxLength <= 0 {
 		return nil, fmt.Errorf("%w but was %d", ErrInvalidMaxLength, maxLength)
 	}
 
-	historicalView, err := db.getHistoricalViewForRange(rootID, start, end)
+	historicalTrie, err := db.getHistoricalTrieForRange(rootID, start, end)
 	if err != nil {
 		return nil, err
 	}
-	return historicalView.GetRangeProof(ctx, start, end, maxLength)
+	return getRangeProof(historicalTrie, start, end, maxLength)
 }
 
 func (db *merkleDB) GetChangeProof(
@@ -668,6 +626,9 @@ func (db *merkleDB) GetChangeProof(
 	end maybe.Maybe[[]byte],
 	maxLength int,
 ) (*ChangeProof, error) {
+	_, span := db.infoTracer.Start(ctx, "MerkleDB.GetChangeProof")
+	defer span.End()
+
 	if start.HasValue() && end.HasValue() && bytes.Compare(start.Value(), end.Value()) == 1 {
 		return nil, ErrStartAfterEnd
 	}
@@ -714,21 +675,21 @@ func (db *merkleDB) GetChangeProof(
 
 	// Since we hold [db.commitlock] we must still have sufficient
 	// history to recreate the trie at [endRootID].
-	historicalView, err := db.getHistoricalViewForRange(endRootID, start, largestKey)
+	historicalTrie, err := db.getHistoricalTrieForRange(endRootID, start, largestKey)
 	if err != nil {
 		return nil, err
 	}
 
 	if largestKey.HasValue() {
-		endProof, err := historicalView.getProof(ctx, largestKey.Value())
+		endProof, err := getProof(historicalTrie, largestKey.Value())
 		if err != nil {
 			return nil, err
 		}
 		result.EndProof = endProof.Path
 	}
 
 	if start.HasValue() {
-		startProof, err := historicalView.getProof(ctx, start.Value())
+		startProof, err := getProof(historicalTrie, start.Value())
 		if err != nil {
 			return nil, err
 		}
@@ -765,7 +726,7 @@ func (db *merkleDB) GetChangeProof(
 func (db *merkleDB) NewView(
 	_ context.Context,
 	changes ViewChanges,
-) (TrieView, error) {
+) (View, error) {
 	// ensure the db doesn't change while creating the new view
 	db.commitLock.RLock()
 	defer db.commitLock.RUnlock()
@@ -1183,7 +1144,7 @@ func (db *merkleDB) initializeRoot() error {
 	}
 
 	db.rootID = db.sentinelNode.calculateID(db.metrics)
-	if !isSentinelNodeTheRoot(db.sentinelNode) {
+	if !isSentinelNodeTheRoot(db) {
 		// If the sentinel node is not the root, the trie's root is the sentinel node's only child
 		for _, childEntry := range db.sentinelNode.children {
 			db.rootID = childEntry.id
@@ -1197,24 +1158,21 @@ func (db *merkleDB) initializeRoot() error {
 // If [end] is Nothing, there's no upper bound on the range.
 // Assumes [db.commitLock] is read locked.
 // Assumes [db.lock] isn't held.
-func (db *merkleDB) getHistoricalViewForRange(
+func (db *merkleDB) getHistoricalTrieForRange(
 	rootID ids.ID,
 	start maybe.Maybe[[]byte],
 	end maybe.Maybe[[]byte],
-) (*trieView, error) {
-	currentRootID := db.getMerkleRoot()
-
+) (Trie, error) {
 	// looking for the trie's current root id, so return the trie unmodified
-	if currentRootID == rootID {
-		// create an empty trie
-		return newTrieView(db, db, ViewChanges{})
+	if rootID == db.getMerkleRoot() {
+		return db, nil
 	}
 
 	changeHistory, err := db.history.getChangesToGetToRoot(rootID, start, end)
 	if err != nil {
 		return nil, err
 	}
-	return newHistoricalTrieView(db, changeHistory)
+	return newHistoricalView(db, changeHistory)
 }
 
 // Returns all keys in range [start, end] that aren't in [keySet].
@@ -1302,6 +1260,14 @@ func (db *merkleDB) Clear() error {
 	return nil
 }
 
+func (db *merkleDB) getSentinelNode() *node {
+	return db.sentinelNode
+}
+
+func (db *merkleDB) getTokenSize() int {
+	return db.tokenSize
+}
+
 // Returns [key] prefixed by [prefix].
 // The returned []byte is taken from [bufferPool] and
 // should be returned to it when the caller is done with it.