triedb, triedb/internal, triedb/pathdb: add GenerateTrie + extract shared pipeline into triedb/internal (#34654)

This PR adds `GenerateTrie(db, scheme, root)` to the `triedb` package,
which rebuilds all tries from flat snapshot KV data. This is needed by
snap/2 sync so it can rebuild the trie after downloading the flat state.
The shared trie generation pipeline from `pathdb/verifier.go` was moved
into `triedb/internal/conversion.go` so both `GenerateTrie` and
`VerifyState` reuse the same code.

Author: jrhea

triedb/generate.go

@@ -0,0 +1,108 @@
+// Copyright 2026 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package triedb
+
+import (
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/triedb/internal"
+)
+
+// kvAccountIterator wraps an ethdb.Iterator to iterate over account snapshot
+// entries in the database, implementing internal.AccountIterator.
+type kvAccountIterator struct {
+	it   ethdb.Iterator
+	hash common.Hash
+}
+
+func newKVAccountIterator(db ethdb.Iteratee) *kvAccountIterator {
+	it := rawdb.NewKeyLengthIterator(
+		db.NewIterator(rawdb.SnapshotAccountPrefix, nil),
+		len(rawdb.SnapshotAccountPrefix)+common.HashLength,
+	)
+	return &kvAccountIterator{it: it}
+}
+
+func (it *kvAccountIterator) Next() bool {
+	if !it.it.Next() {
+		return false
+	}
+	key := it.it.Key()
+	copy(it.hash[:], key[len(rawdb.SnapshotAccountPrefix):])
+	return true
+}
+
+func (it *kvAccountIterator) Hash() common.Hash { return it.hash }
+func (it *kvAccountIterator) Account() []byte   { return it.it.Value() }
+func (it *kvAccountIterator) Error() error      { return it.it.Error() }
+func (it *kvAccountIterator) Release()          { it.it.Release() }
+
+// kvStorageIterator wraps an ethdb.Iterator to iterate over storage snapshot
+// entries for a specific account, implementing internal.StorageIterator.
+type kvStorageIterator struct {
+	it   ethdb.Iterator
+	hash common.Hash
+}
+
+func newKVStorageIterator(db ethdb.Iteratee, accountHash common.Hash) *kvStorageIterator {
+	it := rawdb.IterateStorageSnapshots(db, accountHash)
+	return &kvStorageIterator{it: it}
+}
+
+func (it *kvStorageIterator) Next() bool {
+	if !it.it.Next() {
+		return false
+	}
+	key := it.it.Key()
+	copy(it.hash[:], key[len(rawdb.SnapshotStoragePrefix)+common.HashLength:])
+	return true
+}
+
+func (it *kvStorageIterator) Hash() common.Hash { return it.hash }
+func (it *kvStorageIterator) Slot() []byte      { return it.it.Value() }
+func (it *kvStorageIterator) Error() error      { return it.it.Error() }
+func (it *kvStorageIterator) Release()          { it.it.Release() }
+
+// GenerateTrie rebuilds all tries (storage + account) from flat snapshot data
+// in the database. It reads account and storage snapshots from the KV store,
+// builds tries using StackTrie with streaming node writes, and verifies the
+// computed state root matches the expected root.
+func GenerateTrie(db ethdb.Database, scheme string, root common.Hash) error {
+	acctIt := newKVAccountIterator(db)
+	defer acctIt.Release()
+
+	got, err := internal.GenerateTrieRoot(db, scheme, acctIt, common.Hash{}, internal.StackTrieGenerate, func(dst ethdb.KeyValueWriter, accountHash, codeHash common.Hash, stat *internal.GenerateStats) (common.Hash, error) {
+		storageIt := newKVStorageIterator(db, accountHash)
+		defer storageIt.Release()
+
+		hash, err := internal.GenerateTrieRoot(dst, scheme, storageIt, accountHash, internal.StackTrieGenerate, nil, stat, false)
+		if err != nil {
+			return common.Hash{}, err
+		}
+		return hash, nil
+	}, internal.NewGenerateStats(), true)
+	if err != nil {
+		return err
+	}
+	if got != root {
+		return fmt.Errorf("state root mismatch: got %x, want %x", got, root)
+	}
+	return nil
+}

triedb/generate_test.go

@@ -0,0 +1,178 @@
+// Copyright 2026 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package triedb
+
+import (
+	"bytes"
+	"sort"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/rlp"
+	"github.com/ethereum/go-ethereum/trie"
+	"github.com/holiman/uint256"
+)
+
+// testAccount is a helper for building test state with deterministic ordering.
+type testAccount struct {
+	hash    common.Hash
+	account types.StateAccount
+	storage []testSlot // must be sorted by hash
+}
+
+type testSlot struct {
+	hash  common.Hash
+	value []byte
+}
+
+// buildExpectedRoot computes the state root from sorted test accounts using
+// StackTrie (which requires sorted key insertion).
+func buildExpectedRoot(t *testing.T, accounts []testAccount) common.Hash {
+	t.Helper()
+	// Sort accounts by hash
+	sort.Slice(accounts, func(i, j int) bool {
+		return bytes.Compare(accounts[i].hash[:], accounts[j].hash[:]) < 0
+	})
+	acctTrie := trie.NewStackTrie(nil)
+	for i := range accounts {
+		data, err := rlp.EncodeToBytes(&accounts[i].account)
+		if err != nil {
+			t.Fatal(err)
+		}
+		acctTrie.Update(accounts[i].hash[:], data)
+	}
+	return acctTrie.Hash()
+}
+
+// computeStorageRoot computes the storage trie root from sorted slots.
+func computeStorageRoot(slots []testSlot) common.Hash {
+	sort.Slice(slots, func(i, j int) bool {
+		return bytes.Compare(slots[i].hash[:], slots[j].hash[:]) < 0
+	})
+	st := trie.NewStackTrie(nil)
+	for _, s := range slots {
+		st.Update(s.hash[:], s.value)
+	}
+	return st.Hash()
+}
+
+func TestGenerateTrieEmpty(t *testing.T) {
+	db := rawdb.NewMemoryDatabase()
+	if err := GenerateTrie(db, rawdb.HashScheme, types.EmptyRootHash); err != nil {
+		t.Fatalf("GenerateTrie on empty state failed: %v", err)
+	}
+}
+
+func TestGenerateTrieAccountsOnly(t *testing.T) {
+	db := rawdb.NewMemoryDatabase()
+
+	accounts := []testAccount{
+		{
+			hash: common.HexToHash("0x01"),
+			account: types.StateAccount{
+				Nonce:    1,
+				Balance:  uint256.NewInt(100),
+				Root:     types.EmptyRootHash,
+				CodeHash: types.EmptyCodeHash.Bytes(),
+			},
+		},
+		{
+			hash: common.HexToHash("0x02"),
+			account: types.StateAccount{
+				Nonce:    2,
+				Balance:  uint256.NewInt(200),
+				Root:     types.EmptyRootHash,
+				CodeHash: types.EmptyCodeHash.Bytes(),
+			},
+		},
+	}
+	for _, a := range accounts {
+		rawdb.WriteAccountSnapshot(db, a.hash, types.SlimAccountRLP(a.account))
+	}
+	root := buildExpectedRoot(t, accounts)
+
+	if err := GenerateTrie(db, rawdb.HashScheme, root); err != nil {
+		t.Fatalf("GenerateTrie failed: %v", err)
+	}
+}
+
+func TestGenerateTrieWithStorage(t *testing.T) {
+	db := rawdb.NewMemoryDatabase()
+
+	slots := []testSlot{
+		{hash: common.HexToHash("0xaa"), value: []byte{0x01, 0x02, 0x03}},
+		{hash: common.HexToHash("0xbb"), value: []byte{0x04, 0x05, 0x06}},
+	}
+	storageRoot := computeStorageRoot(slots)
+
+	accounts := []testAccount{
+		{
+			hash: common.HexToHash("0x01"),
+			account: types.StateAccount{
+				Nonce:    1,
+				Balance:  uint256.NewInt(100),
+				Root:     storageRoot,
+				CodeHash: types.EmptyCodeHash.Bytes(),
+			},
+			storage: slots,
+		},
+		{
+			hash: common.HexToHash("0x02"),
+			account: types.StateAccount{
+				Nonce:    0,
+				Balance:  uint256.NewInt(50),
+				Root:     types.EmptyRootHash,
+				CodeHash: types.EmptyCodeHash.Bytes(),
+			},
+		},
+	}
+	// Write account snapshots
+	for _, a := range accounts {
+		rawdb.WriteAccountSnapshot(db, a.hash, types.SlimAccountRLP(a.account))
+	}
+	// Write storage snapshots
+	for _, a := range accounts {
+		for _, s := range a.storage {
+			rawdb.WriteStorageSnapshot(db, a.hash, s.hash, s.value)
+		}
+	}
+	root := buildExpectedRoot(t, accounts)
+
+	if err := GenerateTrie(db, rawdb.HashScheme, root); err != nil {
+		t.Fatalf("GenerateTrie failed: %v", err)
+	}
+}
+
+func TestGenerateTrieRootMismatch(t *testing.T) {
+	db := rawdb.NewMemoryDatabase()
+
+	acct := types.StateAccount{
+		Nonce:    1,
+		Balance:  uint256.NewInt(100),
+		Root:     types.EmptyRootHash,
+		CodeHash: types.EmptyCodeHash.Bytes(),
+	}
+	rawdb.WriteAccountSnapshot(db, common.HexToHash("0x01"), types.SlimAccountRLP(acct))
+
+	wrongRoot := common.HexToHash("0xdeadbeef")
+	err := GenerateTrie(db, rawdb.HashScheme, wrongRoot)
+	if err == nil {
+		t.Fatal("expected error for root mismatch, got nil")
+	}
+}