MerkleDB Adjust New View function(s)

x/merkledb/db.go

@@ -38,7 +38,6 @@ const (
 )
 
 var (
-	_ TrieView = (*merkleDB)(nil)
 	_ MerkleDB = (*merkleDB)(nil)
 
 	codec = newCodec()
@@ -50,7 +49,8 @@ var (
 	hadCleanShutdown        = []byte{1}
 	didNotHaveCleanShutdown = []byte{0}
 
-	errSameRoot = errors.New("start and end root are the same")
+	errSameRoot  = errors.New("start and end root are the same")
+	errNoNewRoot = errors.New("there was no updated root in change list")
 )
 
 type ChangeProofer interface {
@@ -255,7 +255,7 @@ func (db *merkleDB) rebuild(ctx context.Context) error {
 
 	for it.Next() {
 		if len(currentOps) >= viewSizeLimit {
-			view, err := db.newUntrackedView(currentOps)
+			view, err := db.newUntrackedView(currentOps, true)
 			if err != nil {
 				return err
 			}
@@ -282,7 +282,7 @@ func (db *merkleDB) rebuild(ctx context.Context) error {
 	if err := it.Error(); err != nil {
 		return err
 	}
-	view, err := db.newUntrackedView(currentOps)
+	view, err := db.newUntrackedView(currentOps, true)
 	if err != nil {
 		return err
 	}
@@ -308,7 +308,7 @@ func (db *merkleDB) CommitChangeProof(ctx context.Context, proof *ChangeProof) e
 		}
 	}
 
-	view, err := db.newUntrackedView(ops)
+	view, err := db.newUntrackedView(ops, false)
 	if err != nil {
 		return err
 	}
@@ -349,7 +349,7 @@ func (db *merkleDB) CommitRangeProof(ctx context.Context, start maybe.Maybe[[]by
 	}
 
 	// Don't need to lock [view] because nobody else has a reference to it.
-	view, err := db.newUntrackedView(ops)
+	view, err := db.newUntrackedView(ops, false)
 	if err != nil {
 		return err
 	}
@@ -504,7 +504,7 @@ func (db *merkleDB) getProof(ctx context.Context, key []byte) (*Proof, error) {
 		return nil, database.ErrClosed
 	}
 
-	view, err := db.newUntrackedView(nil)
+	view, err := db.newUntrackedView(nil, true)
 	if err != nil {
 		return nil, err
 	}
@@ -655,15 +655,26 @@ func (db *merkleDB) GetChangeProof(
 	return result, nil
 }
 
-// NewView returns a new view on top of this trie.
-// Changes made to the view will only be reflected in the original trie if Commit is called.
+// NewView returns a new view on top of this Trie where the passed changes
+// have been applied.
+//
+// Changes made to the view will only be reflected in the original trie if
+// Commit is called.
+//
 // Assumes [db.commitLock] and [db.lock] aren't held.
-func (db *merkleDB) NewView(_ context.Context, batchOps []database.BatchOp) (TrieView, error) {
+func (db *merkleDB) NewView(
+	_ context.Context,
+	changes ViewChanges,
+) (TrieView, error) {
 	// ensure the db doesn't change while creating the new view
 	db.commitLock.RLock()
 	defer db.commitLock.RUnlock()
 
-	newView, err := db.newUntrackedView(batchOps)
+	if db.closed {
+		return nil, database.ErrClosed
+	}
+
+	newView, err := newTrieView(db, db, db.root.clone(), changes)
 	if err != nil {
 		return nil, err
 	}
@@ -679,16 +690,16 @@ func (db *merkleDB) NewView(_ context.Context, batchOps []database.BatchOp) (Tri
 // Returns a new view that isn't tracked in [db.childViews].
 // For internal use only, namely in methods that create short-lived views.
 // Assumes [db.lock] isn't held and [db.commitLock] is read locked.
-func (db *merkleDB) newUntrackedView(batchOps []database.BatchOp) (*trieView, error) {
-	if db.closed {
-		return nil, database.ErrClosed
-	}
-
-	newView, err := newTrieView(db, db, db.root.clone(), batchOps)
-	if err != nil {
-		return nil, err
-	}
-	return newView, nil
+func (db *merkleDB) newUntrackedView(batchOps []database.BatchOp, consumeBytes bool) (*trieView, error) {
+	return newTrieView(
+		db,
+		db,
+		db.root.clone(),
+		ViewChanges{
+			BatchOps:     batchOps,
+			ConsumeBytes: consumeBytes,
+		},
+	)
 }
 
 func (db *merkleDB) Has(k []byte) (bool, error) {
@@ -820,12 +831,13 @@ func (db *merkleDB) PutContext(ctx context.Context, k, v []byte) error {
 		return database.ErrClosed
 	}
 
-	view, err := db.newUntrackedView([]database.BatchOp{
-		{
+	view, err := db.newUntrackedView(
+		[]database.BatchOp{{
 			Key:   k,
 			Value: v,
-		},
-	})
+		}},
+		false,
+	)
 	if err != nil {
 		return err
 	}
@@ -844,18 +856,21 @@ func (db *merkleDB) DeleteContext(ctx context.Context, key []byte) error {
 		return database.ErrClosed
 	}
 
-	view, err := db.newUntrackedView([]database.BatchOp{
-		{
+	view, err := db.newUntrackedView(
+		[]database.BatchOp{{
 			Key:    key,
 			Delete: true,
-		},
-	})
+		}},
+		true,
+	)
 	if err != nil {
 		return err
 	}
 	return view.commitToDB(ctx)
 }
 
+// Assumes values inside of [ops] are safe to reference after the function
+// returns.
 func (db *merkleDB) commitBatch(ops []database.BatchOp) error {
 	db.commitLock.Lock()
 	defer db.commitLock.Unlock()
@@ -864,7 +879,7 @@ func (db *merkleDB) commitBatch(ops []database.BatchOp) error {
 		return database.ErrClosed
 	}
 
-	view, err := db.newUntrackedView(ops)
+	view, err := db.newUntrackedView(ops, true)
 	if err != nil {
 		return err
 	}
@@ -1042,6 +1057,10 @@ func (db *merkleDB) VerifyChangeProof(
 	db.commitLock.RLock()
 	defer db.commitLock.RUnlock()
 
+	if db.closed {
+		return database.ErrClosed
+	}
+
 	if err := verifyAllChangeProofKeyValuesPresent(
 		ctx,
 		db,
@@ -1075,7 +1094,7 @@ func (db *merkleDB) VerifyChangeProof(
 	}
 
 	// Don't need to lock [view] because nobody else has a reference to it.
-	view, err := db.newUntrackedView(ops)
+	view, err := db.newUntrackedView(ops, true)
 	if err != nil {
 		return err
 	}
@@ -1184,7 +1203,8 @@ func (db *merkleDB) getHistoricalViewForRange(
 
 	// looking for the trie's current root id, so return the trie unmodified
 	if currentRootID == rootID {
-		return newTrieView(db, db, db.root.clone(), nil)
+		// create an empty trie
+		return newTrieView(db, db, db.root.clone(), ViewChanges{})
 	}
 
 	changeHistory, err := db.history.getChangesToGetToRoot(rootID, start, end)

x/merkledb/db_test.go

@@ -125,7 +125,7 @@ func Test_MerkleDB_DB_Load_Root_From_DB(t *testing.T) {
 		k := []byte(strconv.Itoa(i))
 		ops = append(ops, database.BatchOp{Key: k, Value: hashing.ComputeHash256(k)})
 	}
-	view, err := db.NewView(context.Background(), ops)
+	view, err := db.NewView(context.Background(), ViewChanges{BatchOps: ops})
 	require.NoError(err)
 	require.NoError(view.CommitToDB(context.Background()))
 
@@ -171,7 +171,7 @@ func Test_MerkleDB_DB_Rebuild(t *testing.T) {
 		k := []byte(strconv.Itoa(i))
 		ops = append(ops, database.BatchOp{Key: k, Value: hashing.ComputeHash256(k)})
 	}
-	view, err := db.NewView(context.Background(), ops)
+	view, err := db.NewView(context.Background(), ViewChanges{BatchOps: ops})
 	require.NoError(err)
 	require.NoError(view.CommitToDB(context.Background()))
 
@@ -246,12 +246,19 @@ func Test_MerkleDB_Invalidate_Siblings_On_Commit(t *testing.T) {
 	require.NoError(err)
 	require.NotNil(dbTrie)
 
-	viewToCommit, err := dbTrie.NewView(context.Background(), []database.BatchOp{{Key: []byte{0}, Value: []byte{0}}})
+	viewToCommit, err := dbTrie.NewView(
+		context.Background(),
+		ViewChanges{
+			BatchOps: []database.BatchOp{
+				{Key: []byte{0}, Value: []byte{0}},
+			},
+		},
+	)
 	require.NoError(err)
 
-	sibling1, err := dbTrie.NewView(context.Background(), nil)
+	sibling1, err := dbTrie.NewView(context.Background(), ViewChanges{})
 	require.NoError(err)
-	sibling2, err := dbTrie.NewView(context.Background(), nil)
+	sibling2, err := dbTrie.NewView(context.Background(), ViewChanges{})
 	require.NoError(err)
 
 	require.False(sibling1.(*trieView).isInvalid())
@@ -456,7 +463,12 @@ func TestDatabaseNewUntrackedView(t *testing.T) {
 	require.NoError(err)
 
 	// Create a new untracked view.
-	view, err := db.newUntrackedView([]database.BatchOp{{Key: []byte{1}, Value: []byte{1}}})
+	view, err := db.newUntrackedView(
+		[]database.BatchOp{
+			{Key: []byte{1}, Value: []byte{1}},
+		},
+		false,
+	)
 	require.NoError(err)
 	require.Empty(db.childViews)
 
@@ -468,14 +480,21 @@ func TestDatabaseNewUntrackedView(t *testing.T) {
 }
 
 // Test that tracked views are persisted to [db.childViews].
-func TestDatabaseNewViewTracked(t *testing.T) {
+func TestDatabaseNewViewFromBatchOpsTracked(t *testing.T) {
 	require := require.New(t)
 
 	db, err := getBasicDB()
 	require.NoError(err)
 
 	// Create a new tracked view.
-	view, err := db.NewView(context.Background(), []database.BatchOp{{Key: []byte{1}, Value: []byte{1}}})
+	view, err := db.NewView(
+		context.Background(),
+		ViewChanges{
+			BatchOps: []database.BatchOp{
+				{Key: []byte{1}, Value: []byte{1}},
+			},
+		},
+	)
 	require.NoError(err)
 	require.Len(db.childViews, 1)
 
@@ -499,7 +518,7 @@ func TestDatabaseCommitChanges(t *testing.T) {
 	require.Equal(dbRoot, db.getMerkleRoot()) // Root didn't change
 
 	// Committing an invalid view should fail.
-	invalidView, err := db.NewView(context.Background(), nil)
+	invalidView, err := db.NewView(context.Background(), ViewChanges{})
 	require.NoError(err)
 	invalidView.(*trieView).invalidate()
 	err = invalidView.CommitToDB(context.Background())
@@ -510,24 +529,29 @@ func TestDatabaseCommitChanges(t *testing.T) {
 	require.NoError(db.Put([]byte{2}, []byte{2}))
 
 	// Make a view and insert/delete a key-value pair.
-	view1Intf, err := db.NewView(context.Background(), []database.BatchOp{
-		{Key: []byte{3}, Value: []byte{3}},
-		{Key: []byte{1}, Delete: true},
-	})
+	view1Intf, err := db.NewView(
+		context.Background(),
+		ViewChanges{
+			BatchOps: []database.BatchOp{
+				{Key: []byte{3}, Value: []byte{3}},
+				{Key: []byte{1}, Delete: true},
+			},
+		},
+	)
 	require.NoError(err)
 	require.IsType(&trieView{}, view1Intf)
 	view1 := view1Intf.(*trieView)
 	view1Root, err := view1.GetMerkleRoot(context.Background())
 	require.NoError(err)
 
 	// Make a second view
-	view2Intf, err := db.NewView(context.Background(), nil)
+	view2Intf, err := db.NewView(context.Background(), ViewChanges{})
 	require.NoError(err)
 	require.IsType(&trieView{}, view2Intf)
 	view2 := view2Intf.(*trieView)
 
 	// Make a view atop a view
-	view3Intf, err := view1.NewView(context.Background(), nil)
+	view3Intf, err := view1.NewView(context.Background(), ViewChanges{})
 	require.NoError(err)
 	require.IsType(&trieView{}, view3Intf)
 	view3 := view3Intf.(*trieView)
@@ -577,17 +601,17 @@ func TestDatabaseInvalidateChildrenExcept(t *testing.T) {
 	require.NoError(err)
 
 	// Create children
-	view1Intf, err := db.NewView(context.Background(), nil)
+	view1Intf, err := db.NewView(context.Background(), ViewChanges{})
 	require.NoError(err)
 	require.IsType(&trieView{}, view1Intf)
 	view1 := view1Intf.(*trieView)
 
-	view2Intf, err := db.NewView(context.Background(), nil)
+	view2Intf, err := db.NewView(context.Background(), ViewChanges{})
 	require.NoError(err)
 	require.IsType(&trieView{}, view2Intf)
 	view2 := view2Intf.(*trieView)
 
-	view3Intf, err := db.NewView(context.Background(), nil)
+	view3Intf, err := db.NewView(context.Background(), ViewChanges{})
 	require.NoError(err)
 	require.IsType(&trieView{}, view3Intf)
 	view3 := view3Intf.(*trieView)
@@ -668,15 +692,15 @@ func Test_MerkleDB_Random_Insert_Ordering(t *testing.T) {
 		}
 		db, err := getBasicDB()
 		require.NoError(err)
-		result, err := db.NewView(context.Background(), ops)
+		result, err := db.NewView(context.Background(), ViewChanges{BatchOps: ops})
 		require.NoError(err)
 		primaryRoot, err := result.GetMerkleRoot(context.Background())
 		require.NoError(err)
 		for shuffleIndex := 0; shuffleIndex < 3; shuffleIndex++ {
 			r.Shuffle(totalState, func(i, j int) {
 				ops[i], ops[j] = ops[j], ops[i]
 			})
-			result, err := db.NewView(context.Background(), ops)
+			result, err := db.NewView(context.Background(), ViewChanges{BatchOps: ops})
 			require.NoError(err)
 			newRoot, err := result.GetMerkleRoot(context.Background())
 			require.NoError(err)
@@ -855,7 +879,7 @@ func runRandDBTest(require *require.Assertions, r *rand.Rand, rt randTest) {
 			for key, value := range values {
 				ops = append(ops, database.BatchOp{Key: key.Serialize().Value, Value: value})
 			}
-			newView, err := dbTrie.NewView(context.Background(), ops)
+			newView, err := dbTrie.NewView(context.Background(), ViewChanges{BatchOps: ops})
 			require.NoError(err)
 
 			calculatedRoot, err := newView.GetMerkleRoot(context.Background())

x/merkledb/proof.go

@@ -882,5 +882,5 @@ func getStandaloneTrieView(ctx context.Context, ops []database.BatchOp) (*trieVi
 		return nil, err
 	}
 
-	return db.newUntrackedView(ops)
+	return db.newUntrackedView(ops, true)
 }