simpify binary tree recursion

core/chain_makers.go

@@ -427,7 +427,11 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse
 	}
 
 	// Forcibly use hash-based state scheme for retaining all nodes in disk.
-	triedb := triedb.NewDatabase(db, triedb.HashDefaults)
+	var triedbConfig *triedb.Config = triedb.HashDefaults
+	if config.IsVerkle(config.ChainID, 0) {
+		triedbConfig = triedb.VerkleDefaults
+	}
+	triedb := triedb.NewDatabase(db, triedbConfig)
 	defer triedb.Close()
 
 	for i := 0; i < n; i++ {
@@ -472,7 +476,11 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse
 // then generate chain on top.
 func GenerateChainWithGenesis(genesis *Genesis, engine consensus.Engine, n int, gen func(int, *BlockGen)) (ethdb.Database, []*types.Block, []types.Receipts) {
 	db := rawdb.NewMemoryDatabase()
-	triedb := triedb.NewDatabase(db, triedb.HashDefaults)
+	var triedbConfig *triedb.Config = triedb.HashDefaults
+	if genesis.Config != nil && genesis.Config.IsVerkle(genesis.Config.ChainID, 0) {
+		triedbConfig = triedb.VerkleDefaults
+	}
+	triedb := triedb.NewDatabase(db, triedbConfig)
 	defer triedb.Close()
 	_, err := genesis.Commit(db, triedb)
 	if err != nil {

trie/bintrie/internal_node.go

@@ -49,14 +49,8 @@ func (bt *InternalNode) GetValuesAtStem(stem []byte, resolver NodeResolverFn) ([
 	}
 
 	bit := stem[bt.depth/8] >> (7 - (bt.depth % 8)) & 1
-	var child *BinaryNode
 	if bit == 0 {
-		child = &bt.left
+		if hn, ok := bt.left.(HashedNode); ok {
-	} else {
-		child = &bt.right
-	}
-
-	if hn, ok := (*child).(HashedNode); ok {
 			path, err := keyToPath(bt.depth, stem)
 			if err != nil {
 				return nil, fmt.Errorf("GetValuesAtStem resolve error: %w", err)
@@ -69,9 +63,28 @@ func (bt *InternalNode) GetValuesAtStem(stem []byte, resolver NodeResolverFn) ([
 			if err != nil {
 				return nil, fmt.Errorf("GetValuesAtStem node deserialization error: %w", err)
 			}
-		*child = node
+			bt.left = node
 		}
-	return (*child).GetValuesAtStem(stem, resolver)
+		return bt.left.GetValuesAtStem(stem, resolver)
+
+	}
+
+	if hn, ok := bt.right.(HashedNode); ok {
+		path, err := keyToPath(bt.depth, stem)
+		if err != nil {
+			return nil, fmt.Errorf("GetValuesAtStem resolve error: %w", err)
+		}
+		data, err := resolver(path, common.Hash(hn))
+		if err != nil {
+			return nil, fmt.Errorf("GetValuesAtStem resolve error: %w", err)
+		}
+		node, err := DeserializeNode(data, bt.depth+1)
+		if err != nil {
+			return nil, fmt.Errorf("GetValuesAtStem node deserialization error: %w", err)
+		}
+		bt.right = node
+	}
+	return bt.right.GetValuesAtStem(stem, resolver)
 }
 
 // Get retrieves the value for the given key.
@@ -118,23 +131,54 @@ func (bt *InternalNode) Hash() common.Hash {
 // InsertValuesAtStem inserts a full value group at the given stem in the internal node.
 // Already-existing values will be overwritten.
 func (bt *InternalNode) InsertValuesAtStem(stem []byte, values [][]byte, resolver NodeResolverFn, depth int) (BinaryNode, error) {
-	var (
+	var err error
-		child *BinaryNode
-		err   error
-	)
 	bit := stem[bt.depth/8] >> (7 - (bt.depth % 8)) & 1
 	if bit == 0 {
-		child = &bt.left
+		if bt.left == nil {
-	} else {
+			bt.left = Empty{}
-		child = &bt.right
 		}
 
-	// Initialize child to Empty if it's nil
+		if hn, ok := bt.left.(HashedNode); ok {
-	if *child == nil {
+			path, err := keyToPath(bt.depth, stem)
-		*child = Empty{}
+			if err != nil {
+				return nil, fmt.Errorf("InsertValuesAtStem resolve error: %w", err)
+			}
+			data, err := resolver(path, common.Hash(hn))
+			if err != nil {
+				return nil, fmt.Errorf("InsertValuesAtStem resolve error: %w", err)
+			}
+			node, err := DeserializeNode(data, bt.depth+1)
+			if err != nil {
+				return nil, fmt.Errorf("InsertValuesAtStem node deserialization error: %w", err)
+			}
+			bt.left = node
 		}
 
-	*child, err = (*child).InsertValuesAtStem(stem, values, resolver, depth+1)
+		bt.left, err = bt.left.InsertValuesAtStem(stem, values, resolver, depth+1)
+		return bt, err
+	}
+
+	if bt.right == nil {
+		bt.right = Empty{}
+	}
+
+	if hn, ok := bt.right.(HashedNode); ok {
+		path, err := keyToPath(bt.depth, stem)
+		if err != nil {
+			return nil, fmt.Errorf("InsertValuesAtStem resolve error: %w", err)
+		}
+		data, err := resolver(path, common.Hash(hn))
+		if err != nil {
+			return nil, fmt.Errorf("InsertValuesAtStem resolve error: %w", err)
+		}
+		node, err := DeserializeNode(data, bt.depth+1)
+		if err != nil {
+			return nil, fmt.Errorf("InsertValuesAtStem node deserialization error: %w", err)
+		}
+		bt.right = node
+	}
+
+	bt.right, err = bt.right.InsertValuesAtStem(stem, values, resolver, depth+1)
 	return bt, err
 }