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.

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")
+	}
+}

triedb/internal/conversion.go

@@ -0,0 +1,363 @@
+// 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 internal contains shared trie generation utilities used by both
+// triedb and triedb/pathdb. All code is ported from
+// core/state/snapshot/conversion.go (with exported names) unless noted.
+package internal
+
+import (
+	"encoding/binary"
+	"fmt"
+	"math"
+	"runtime"
+	"sync"
+	"time"
+
+	"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/ethdb"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/rlp"
+	"github.com/ethereum/go-ethereum/trie"
+)
+
+// Iterator is an iterator to step over all the accounts or the specific
+// storage in a snapshot which may or may not be composed of multiple layers.
+type Iterator interface {
+	// Next steps the iterator forward one element, returning false if exhausted,
+	// or an error if iteration failed for some reason (e.g. root being iterated
+	// becomes stale and garbage collected).
+	Next() bool
+
+	// Error returns any failure that occurred during iteration, which might have
+	// caused a premature iteration exit (e.g. snapshot stack becoming stale).
+	Error() error
+
+	// Hash returns the hash of the account or storage slot the iterator is
+	// currently at.
+	Hash() common.Hash
+
+	// Release releases associated resources. Release should always succeed and
+	// can be called multiple times without causing error.
+	Release()
+}
+
+// AccountIterator is an iterator to step over all the accounts in a snapshot,
+// which may or may not be composed of multiple layers.
+type AccountIterator interface {
+	Iterator
+
+	// Account returns the RLP encoded slim account the iterator is currently at.
+	// An error will be returned if the iterator becomes invalid
+	Account() []byte
+}
+
+// StorageIterator is an iterator to step over the specific storage in a snapshot,
+// which may or may not be composed of multiple layers.
+type StorageIterator interface {
+	Iterator
+
+	// Slot returns the storage slot the iterator is currently at. An error will
+	// be returned if the iterator becomes invalid
+	Slot() []byte
+}
+
+// TrieKV represents a trie key-value pair.
+type TrieKV struct {
+	Key   common.Hash
+	Value []byte
+}
+
+type (
+	// TrieGeneratorFn is the interface of trie generation which can
+	// be implemented by different trie algorithm.
+	TrieGeneratorFn func(db ethdb.KeyValueWriter, scheme string, owner common.Hash, in chan (TrieKV), out chan (common.Hash))
+
+	// LeafCallbackFn is the callback invoked at the leaves of the trie,
+	// returns the subtrie root with the specified subtrie identifier.
+	LeafCallbackFn func(db ethdb.KeyValueWriter, accountHash, codeHash common.Hash, stat *GenerateStats) (common.Hash, error)
+)
+
+// GenerateStats is a collection of statistics gathered by the trie generator
+// for logging purposes.
+type GenerateStats struct {
+	head  common.Hash
+	start time.Time
+
+	accounts uint64 // Number of accounts done (including those being crawled)
+	slots    uint64 // Number of storage slots done (including those being crawled)
+
+	slotsStart map[common.Hash]time.Time   // Start time for account slot crawling
+	slotsHead  map[common.Hash]common.Hash // Slot head for accounts being crawled
+
+	lock sync.RWMutex
+}
+
+// NewGenerateStats creates a new generator stats.
+func NewGenerateStats() *GenerateStats {
+	return &GenerateStats{
+		slotsStart: make(map[common.Hash]time.Time),
+		slotsHead:  make(map[common.Hash]common.Hash),
+		start:      time.Now(),
+	}
+}
+
+// ProgressAccounts updates the generator stats for the account range.
+func (stat *GenerateStats) ProgressAccounts(account common.Hash, done uint64) {
+	stat.lock.Lock()
+	defer stat.lock.Unlock()
+
+	stat.accounts += done
+	stat.head = account
+}
+
+// FinishAccounts updates the generator stats for the finished account range.
+func (stat *GenerateStats) FinishAccounts(done uint64) {
+	stat.lock.Lock()
+	defer stat.lock.Unlock()
+
+	stat.accounts += done
+}
+
+// ProgressContract updates the generator stats for a specific in-progress contract.
+func (stat *GenerateStats) ProgressContract(account common.Hash, slot common.Hash, done uint64) {
+	stat.lock.Lock()
+	defer stat.lock.Unlock()
+
+	stat.slots += done
+	stat.slotsHead[account] = slot
+	if _, ok := stat.slotsStart[account]; !ok {
+		stat.slotsStart[account] = time.Now()
+	}
+}
+
+// FinishContract updates the generator stats for a specific just-finished contract.
+func (stat *GenerateStats) FinishContract(account common.Hash, done uint64) {
+	stat.lock.Lock()
+	defer stat.lock.Unlock()
+
+	stat.slots += done
+	delete(stat.slotsHead, account)
+	delete(stat.slotsStart, account)
+}
+
+// Report prints the cumulative progress statistic smartly.
+func (stat *GenerateStats) Report() {
+	stat.lock.RLock()
+	defer stat.lock.RUnlock()
+
+	ctx := []interface{}{
+		"accounts", stat.accounts,
+		"slots", stat.slots,
+		"elapsed", common.PrettyDuration(time.Since(stat.start)),
+	}
+	if stat.accounts > 0 {
+		if done := binary.BigEndian.Uint64(stat.head[:8]) / stat.accounts; done > 0 {
+			var (
+				left = (math.MaxUint64 - binary.BigEndian.Uint64(stat.head[:8])) / stat.accounts
+				eta  = common.CalculateETA(done, left, time.Since(stat.start))
+			)
+			// If there are large contract crawls in progress, estimate their finish time
+			for acc, head := range stat.slotsHead {
+				start := stat.slotsStart[acc]
+				if done := binary.BigEndian.Uint64(head[:8]); done > 0 {
+					left := math.MaxUint64 - binary.BigEndian.Uint64(head[:8])
+
+					// Override the ETA if larger than the largest until now
+					if slotETA := common.CalculateETA(done, left, time.Since(start)); eta < slotETA {
+						eta = slotETA
+					}
+				}
+			}
+			ctx = append(ctx, []interface{}{
+				"eta", common.PrettyDuration(eta),
+			}...)
+		}
+	}
+	log.Info("Iterating state snapshot", ctx...)
+}
+
+// ReportDone prints the last log when the whole generation is finished.
+func (stat *GenerateStats) ReportDone() {
+	stat.lock.RLock()
+	defer stat.lock.RUnlock()
+
+	var ctx []interface{}
+	ctx = append(ctx, []interface{}{"accounts", stat.accounts}...)
+	if stat.slots != 0 {
+		ctx = append(ctx, []interface{}{"slots", stat.slots}...)
+	}
+	ctx = append(ctx, []interface{}{"elapsed", common.PrettyDuration(time.Since(stat.start))}...)
+	log.Info("Iterated snapshot", ctx...)
+}
+
+// RunReport periodically prints the progress information.
+func RunReport(stats *GenerateStats, stop chan bool) {
+	timer := time.NewTimer(0)
+	defer timer.Stop()
+
+	for {
+		select {
+		case <-timer.C:
+			stats.Report()
+			timer.Reset(time.Second * 8)
+		case success := <-stop:
+			if success {
+				stats.ReportDone()
+			}
+			return
+		}
+	}
+}
+
+// GenerateTrieRoot generates the trie hash based on the snapshot iterator.
+// It can be used for generating account trie, storage trie or even the
+// whole state which connects the accounts and the corresponding storages.
+func GenerateTrieRoot(db ethdb.KeyValueWriter, scheme string, it Iterator, account common.Hash, generatorFn TrieGeneratorFn, leafCallback LeafCallbackFn, stats *GenerateStats, report bool) (common.Hash, error) {
+	var (
+		in      = make(chan TrieKV)         // chan to pass leaves
+		out     = make(chan common.Hash, 1) // chan to collect result
+		stoplog = make(chan bool, 1)        // 1-size buffer, works when logging is not enabled
+		wg      sync.WaitGroup
+	)
+	// Spin up a go-routine for trie hash re-generation
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		generatorFn(db, scheme, account, in, out)
+	}()
+	// Spin up a go-routine for progress logging
+	if report && stats != nil {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			RunReport(stats, stoplog)
+		}()
+	}
+	// Create a semaphore to assign tasks and collect results through. We'll pre-
+	// fill it with nils, thus using the same channel for both limiting concurrent
+	// processing and gathering results.
+	threads := runtime.NumCPU()
+	results := make(chan error, threads)
+	for i := 0; i < threads; i++ {
+		results <- nil // fill the semaphore
+	}
+	// stop is a helper function to shutdown the background threads
+	// and return the re-generated trie hash.
+	stop := func(fail error) (common.Hash, error) {
+		close(in)
+		result := <-out
+		for i := 0; i < threads; i++ {
+			if err := <-results; err != nil && fail == nil {
+				fail = err
+			}
+		}
+		stoplog <- fail == nil
+
+		wg.Wait()
+		return result, fail
+	}
+	var (
+		logged    = time.Now()
+		processed = uint64(0)
+		leaf      TrieKV
+	)
+	// Start to feed leaves
+	for it.Next() {
+		if account == (common.Hash{}) {
+			var (
+				err      error
+				fullData []byte
+			)
+			if leafCallback == nil {
+				fullData, err = types.FullAccountRLP(it.(AccountIterator).Account())
+				if err != nil {
+					return stop(err)
+				}
+			} else {
+				// Wait until the semaphore allows us to continue, aborting if
+				// a sub-task failed
+				if err := <-results; err != nil {
+					results <- nil // stop will drain the results, add a noop back for this error we just consumed
+					return stop(err)
+				}
+				// Fetch the next account and process it concurrently
+				account, err := types.FullAccount(it.(AccountIterator).Account())
+				if err != nil {
+					return stop(err)
+				}
+				go func(hash common.Hash) {
+					subroot, err := leafCallback(db, hash, common.BytesToHash(account.CodeHash), stats)
+					if err != nil {
+						results <- err
+						return
+					}
+					if account.Root != subroot {
+						results <- fmt.Errorf("invalid subroot(path %x), want %x, have %x", hash, account.Root, subroot)
+						return
+					}
+					results <- nil
+				}(it.Hash())
+				fullData, err = rlp.EncodeToBytes(account)
+				if err != nil {
+					return stop(err)
+				}
+			}
+			leaf = TrieKV{it.Hash(), fullData}
+		} else {
+			leaf = TrieKV{it.Hash(), common.CopyBytes(it.(StorageIterator).Slot())}
+		}
+		in <- leaf
+
+		// Accumulate the generation statistic if it's required.
+		processed++
+		if time.Since(logged) > 3*time.Second && stats != nil {
+			if account == (common.Hash{}) {
+				stats.ProgressAccounts(it.Hash(), processed)
+			} else {
+				stats.ProgressContract(account, it.Hash(), processed)
+			}
+			logged, processed = time.Now(), 0
+		}
+	}
+	// Commit the last part statistic.
+	if processed > 0 && stats != nil {
+		if account == (common.Hash{}) {
+			stats.FinishAccounts(processed)
+		} else {
+			stats.FinishContract(account, processed)
+		}
+	}
+	return stop(nil)
+}
+
+// StackTrieGenerate is the trie generation function that creates a StackTrie
+// and persists nodes via rawdb.WriteTrieNode.
+func StackTrieGenerate(db ethdb.KeyValueWriter, scheme string, owner common.Hash, in chan TrieKV, out chan common.Hash) {
+	var onTrieNode trie.OnTrieNode
+	if db != nil {
+		onTrieNode = func(path []byte, hash common.Hash, blob []byte) {
+			rawdb.WriteTrieNode(db, owner, path, hash, blob, scheme)
+		}
+	}
+	t := trie.NewStackTrie(onTrieNode)
+	for leaf := range in {
+		t.Update(leaf.Key[:], leaf.Value)
+	}
+	out <- t.Hash()
+}

triedb/pathdb/iterator.go

@@ -24,48 +24,15 @@ import (
 	"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"
 )
 
-// Iterator is an iterator to step over all the accounts or the specific
+// Type aliases for the iterator interfaces defined in triedb/internal.
-// storage in a snapshot which may or may not be composed of multiple layers.
+type (
-type Iterator interface {
+	Iterator        = internal.Iterator
-	// Next steps the iterator forward one element, returning false if exhausted,
+	AccountIterator = internal.AccountIterator
-	// or an error if iteration failed for some reason (e.g. root being iterated
+	StorageIterator = internal.StorageIterator
-	// becomes stale and garbage collected).
+)
-	Next() bool
-
-	// Error returns any failure that occurred during iteration, which might have
-	// caused a premature iteration exit (e.g. layer stack becoming stale).
-	Error() error
-
-	// Hash returns the hash of the account or storage slot the iterator is
-	// currently at.
-	Hash() common.Hash
-
-	// Release releases associated resources. Release should always succeed and
-	// can be called multiple times without causing error.
-	Release()
-}
-
-// AccountIterator is an iterator to step over all the accounts in a snapshot,
-// which may or may not be composed of multiple layers.
-type AccountIterator interface {
-	Iterator
-
-	// Account returns the RLP encoded slim account the iterator is currently at.
-	// An error will be returned if the iterator becomes invalid
-	Account() []byte
-}
-
-// StorageIterator is an iterator to step over the specific storage in a snapshot,
-// which may or may not be composed of multiple layers.
-type StorageIterator interface {
-	Iterator
-
-	// Slot returns the storage slot the iterator is currently at. An error will
-	// be returned if the iterator becomes invalid
-	Slot() []byte
-}
 
 type (
 	// loadAccount is the function to retrieve the account from the associated

triedb/pathdb/verifier.go

@@ -17,36 +17,15 @@
 package pathdb
 
 import (
-	"encoding/binary"
 	"errors"
 	"fmt"
-	"math"
-	"runtime"
-	"sync"
-	"time"
 
 	"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/log"
+	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/trie"
-)
+	"github.com/ethereum/go-ethereum/triedb/internal"
-
-// trieKV represents a trie key-value pair
-type trieKV struct {
-	key   common.Hash
-	value []byte
-}
-
-type (
-	// trieHasherFn is the interface of trie hasher which can be implemented
-	// by different trie algorithm.
-	trieHasherFn func(in chan trieKV, out chan common.Hash)
-
-	// leafCallbackFn is the callback invoked at the leaves of the trie,
-	// returns the subtrie root with the specified subtrie identifier.
-	leafCallbackFn func(accountHash, codeHash common.Hash, stat *generateStats) (common.Hash, error)
 )
 
 // VerifyState traverses the flat states specified by the given state root and
@@ -58,7 +37,7 @@ func (db *Database) VerifyState(root common.Hash) error {
 	}
 	defer acctIt.Release()
 
-	got, err := generateTrieRoot(acctIt, common.Hash{}, stackTrieHasher, func(accountHash, codeHash common.Hash, stat *generateStats) (common.Hash, error) {
+	got, err := internal.GenerateTrieRoot(nil, "", acctIt, common.Hash{}, stackTrieHasher, func(_ ethdb.KeyValueWriter, accountHash, codeHash common.Hash, stat *internal.GenerateStats) (common.Hash, error) {
 		// Migrate the code first, commit the contract code into the tmp db.
 		if codeHash != types.EmptyCodeHash {
 			code := rawdb.ReadCode(db.diskdb, codeHash)
@@ -73,12 +52,12 @@ func (db *Database) VerifyState(root common.Hash) error {
 		}
 		defer storageIt.Release()
 
-		hash, err := generateTrieRoot(storageIt, accountHash, stackTrieHasher, nil, stat, false)
+		hash, err := internal.GenerateTrieRoot(nil, "", storageIt, accountHash, stackTrieHasher, nil, stat, false)
 		if err != nil {
 			return common.Hash{}, err
 		}
 		return hash, nil
-	}, newGenerateStats(), true)
+	}, internal.NewGenerateStats(), true)
 
 	if err != nil {
 		return err
@@ -89,264 +68,10 @@ func (db *Database) VerifyState(root common.Hash) error {
 	return nil
 }
 
-// generateStats is a collection of statistics gathered by the trie generator
+func stackTrieHasher(_ ethdb.KeyValueWriter, _ string, _ common.Hash, in chan internal.TrieKV, out chan common.Hash) {
-// for logging purposes.
-type generateStats struct {
-	head  common.Hash
-	start time.Time
-
-	accounts uint64 // Number of accounts done (including those being crawled)
-	slots    uint64 // Number of storage slots done (including those being crawled)
-
-	slotsStart map[common.Hash]time.Time   // Start time for account slot crawling
-	slotsHead  map[common.Hash]common.Hash // Slot head for accounts being crawled
-
-	lock sync.RWMutex
-}
-
-// newGenerateStats creates a new generator stats.
-func newGenerateStats() *generateStats {
-	return &generateStats{
-		slotsStart: make(map[common.Hash]time.Time),
-		slotsHead:  make(map[common.Hash]common.Hash),
-		start:      time.Now(),
-	}
-}
-
-// progressAccounts updates the generator stats for the account range.
-func (stat *generateStats) progressAccounts(account common.Hash, done uint64) {
-	stat.lock.Lock()
-	defer stat.lock.Unlock()
-
-	stat.accounts += done
-	stat.head = account
-}
-
-// finishAccounts updates the generator stats for the finished account range.
-func (stat *generateStats) finishAccounts(done uint64) {
-	stat.lock.Lock()
-	defer stat.lock.Unlock()
-
-	stat.accounts += done
-}
-
-// progressContract updates the generator stats for a specific in-progress contract.
-func (stat *generateStats) progressContract(account common.Hash, slot common.Hash, done uint64) {
-	stat.lock.Lock()
-	defer stat.lock.Unlock()
-
-	stat.slots += done
-	stat.slotsHead[account] = slot
-	if _, ok := stat.slotsStart[account]; !ok {
-		stat.slotsStart[account] = time.Now()
-	}
-}
-
-// finishContract updates the generator stats for a specific just-finished contract.
-func (stat *generateStats) finishContract(account common.Hash, done uint64) {
-	stat.lock.Lock()
-	defer stat.lock.Unlock()
-
-	stat.slots += done
-	delete(stat.slotsHead, account)
-	delete(stat.slotsStart, account)
-}
-
-// report prints the cumulative progress statistic smartly.
-func (stat *generateStats) report() {
-	stat.lock.RLock()
-	defer stat.lock.RUnlock()
-
-	ctx := []interface{}{
-		"accounts", stat.accounts,
-		"slots", stat.slots,
-		"elapsed", common.PrettyDuration(time.Since(stat.start)),
-	}
-	if stat.accounts > 0 {
-		// If there's progress on the account trie, estimate the time to finish crawling it
-		if done := binary.BigEndian.Uint64(stat.head[:8]) / stat.accounts; done > 0 {
-			var (
-				left = (math.MaxUint64 - binary.BigEndian.Uint64(stat.head[:8])) / stat.accounts
-				eta  = common.CalculateETA(done, left, time.Since(stat.start))
-			)
-			// If there are large contract crawls in progress, estimate their finish time
-			for acc, head := range stat.slotsHead {
-				start := stat.slotsStart[acc]
-				if done := binary.BigEndian.Uint64(head[:8]); done > 0 {
-					left := math.MaxUint64 - binary.BigEndian.Uint64(head[:8])
-
-					// Override the ETA if larger than the largest until now
-					if slotETA := common.CalculateETA(done, left, time.Since(start)); eta < slotETA {
-						eta = slotETA
-					}
-				}
-			}
-			ctx = append(ctx, []interface{}{
-				"eta", common.PrettyDuration(eta),
-			}...)
-		}
-	}
-	log.Info("Iterating state snapshot", ctx...)
-}
-
-// reportDone prints the last log when the whole generation is finished.
-func (stat *generateStats) reportDone() {
-	stat.lock.RLock()
-	defer stat.lock.RUnlock()
-
-	var ctx []interface{}
-	ctx = append(ctx, []interface{}{"accounts", stat.accounts}...)
-	if stat.slots != 0 {
-		ctx = append(ctx, []interface{}{"slots", stat.slots}...)
-	}
-	ctx = append(ctx, []interface{}{"elapsed", common.PrettyDuration(time.Since(stat.start))}...)
-	log.Info("Iterated snapshot", ctx...)
-}
-
-// runReport periodically prints the progress information.
-func runReport(stats *generateStats, stop chan bool) {
-	timer := time.NewTimer(0)
-	defer timer.Stop()
-
-	for {
-		select {
-		case <-timer.C:
-			stats.report()
-			timer.Reset(time.Second * 8)
-		case success := <-stop:
-			if success {
-				stats.reportDone()
-			}
-			return
-		}
-	}
-}
-
-// generateTrieRoot generates the trie hash based on the snapshot iterator.
-// It can be used for generating account trie, storage trie or even the
-// whole state which connects the accounts and the corresponding storages.
-func generateTrieRoot(it Iterator, account common.Hash, generatorFn trieHasherFn, leafCallback leafCallbackFn, stats *generateStats, report bool) (common.Hash, error) {
-	var (
-		in      = make(chan trieKV)         // chan to pass leaves
-		out     = make(chan common.Hash, 1) // chan to collect result
-		stoplog = make(chan bool, 1)        // 1-size buffer, works when logging is not enabled
-		wg      sync.WaitGroup
-	)
-	// Spin up a go-routine for trie hash re-generation
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		generatorFn(in, out)
-	}()
-	// Spin up a go-routine for progress logging
-	if report && stats != nil {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			runReport(stats, stoplog)
-		}()
-	}
-	// Create a semaphore to assign tasks and collect results through. We'll pre-
-	// fill it with nils, thus using the same channel for both limiting concurrent
-	// processing and gathering results.
-	threads := runtime.NumCPU()
-	results := make(chan error, threads)
-	for i := 0; i < threads; i++ {
-		results <- nil // fill the semaphore
-	}
-	// stop is a helper function to shutdown the background threads
-	// and return the re-generated trie hash.
-	stop := func(fail error) (common.Hash, error) {
-		close(in)
-		result := <-out
-		for i := 0; i < threads; i++ {
-			if err := <-results; err != nil && fail == nil {
-				fail = err
-			}
-		}
-		stoplog <- fail == nil
-
-		wg.Wait()
-		return result, fail
-	}
-	var (
-		logged    = time.Now()
-		processed = uint64(0)
-		leaf      trieKV
-	)
-	// Start to feed leaves
-	for it.Next() {
-		if account == (common.Hash{}) {
-			var (
-				err      error
-				fullData []byte
-			)
-			if leafCallback == nil {
-				fullData, err = types.FullAccountRLP(it.(AccountIterator).Account())
-				if err != nil {
-					return stop(err)
-				}
-			} else {
-				// Wait until the semaphore allows us to continue, aborting if
-				// a sub-task failed
-				if err := <-results; err != nil {
-					results <- nil // stop will drain the results, add a noop back for this error we just consumed
-					return stop(err)
-				}
-				// Fetch the next account and process it concurrently
-				account, err := types.FullAccount(it.(AccountIterator).Account())
-				if err != nil {
-					return stop(err)
-				}
-				go func(hash common.Hash) {
-					subroot, err := leafCallback(hash, common.BytesToHash(account.CodeHash), stats)
-					if err != nil {
-						results <- err
-						return
-					}
-					if account.Root != subroot {
-						results <- fmt.Errorf("invalid subroot(path %x), want %x, have %x", hash, account.Root, subroot)
-						return
-					}
-					results <- nil
-				}(it.Hash())
-				fullData, err = rlp.EncodeToBytes(account)
-				if err != nil {
-					return stop(err)
-				}
-			}
-			leaf = trieKV{it.Hash(), fullData}
-		} else {
-			leaf = trieKV{it.Hash(), common.CopyBytes(it.(StorageIterator).Slot())}
-		}
-		in <- leaf
-
-		// Accumulate the generation statistic if it's required.
-		processed++
-		if time.Since(logged) > 3*time.Second && stats != nil {
-			if account == (common.Hash{}) {
-				stats.progressAccounts(it.Hash(), processed)
-			} else {
-				stats.progressContract(account, it.Hash(), processed)
-			}
-			logged, processed = time.Now(), 0
-		}
-	}
-	// Commit the last part statistic.
-	if processed > 0 && stats != nil {
-		if account == (common.Hash{}) {
-			stats.finishAccounts(processed)
-		} else {
-			stats.finishContract(account, processed)
-		}
-	}
-	return stop(nil)
-}
-
-func stackTrieHasher(in chan trieKV, out chan common.Hash) {
 	t := trie.NewStackTrie(nil)
 	for leaf := range in {
-		t.Update(leaf.key[:], leaf.value)
+		t.Update(leaf.Key[:], leaf.Value)
 	}
 	out <- t.Hash()
 }