diff --git a/trie/iterator_test.go b/trie/iterator_test.go
index f87669ffb6..76eba43f06 100644
--- a/trie/iterator_test.go
+++ b/trie/iterator_test.go
@@ -60,7 +60,7 @@ func TestIterator(t *testing.T) {
 		trie.MustUpdate([]byte(val.k), []byte(val.v))
 	}
 	root, nodes, _ := trie.Commit(false)
-	db.Update(root, types.EmptyLegacyTrieRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
+	db.Update(root, types.EmptyZkTrieRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
 
 	trie, _ = New(TrieID(root), db)
 	found := make(map[string]string)
@@ -127,7 +127,7 @@ type iterationElement struct {
 // Tests that the node iterator indeed walks over the entire database contents.
 func TestNodeIteratorCoverage(t *testing.T) {
 	testNodeIteratorCoverage(t, rawdb.HashScheme)
-	testNodeIteratorCoverage(t, rawdb.PathScheme)
+	// testNodeIteratorCoverage(t, rawdb.PathScheme)
 }
 
 func testNodeIteratorCoverage(t *testing.T, scheme string) {
@@ -252,7 +252,7 @@ func TestDifferenceIterator(t *testing.T) {
 		triea.MustUpdate([]byte(val.k), []byte(val.v))
 	}
 	rootA, nodesA, _ := triea.Commit(false)
-	dba.Update(rootA, types.EmptyLegacyTrieRootHash, 0, trienode.NewWithNodeSet(nodesA), nil)
+	dba.Update(rootA, types.EmptyZkTrieRootHash, 0, trienode.NewWithNodeSet(nodesA), nil)
 	triea, _ = New(TrieID(rootA), dba)
 
 	dbb := NewDatabase(rawdb.NewMemoryDatabase(), nil)
@@ -261,7 +261,7 @@ func TestDifferenceIterator(t *testing.T) {
 		trieb.MustUpdate([]byte(val.k), []byte(val.v))
 	}
 	rootB, nodesB, _ := trieb.Commit(false)
-	dbb.Update(rootB, types.EmptyLegacyTrieRootHash, 0, trienode.NewWithNodeSet(nodesB), nil)
+	dbb.Update(rootB, types.EmptyZkTrieRootHash, 0, trienode.NewWithNodeSet(nodesB), nil)
 	trieb, _ = New(TrieID(rootB), dbb)
 
 	found := make(map[string]string)
@@ -294,7 +294,7 @@ func TestUnionIterator(t *testing.T) {
 		triea.MustUpdate([]byte(val.k), []byte(val.v))
 	}
 	rootA, nodesA, _ := triea.Commit(false)
-	dba.Update(rootA, types.EmptyLegacyTrieRootHash, 0, trienode.NewWithNodeSet(nodesA), nil)
+	dba.Update(rootA, types.EmptyZkTrieRootHash, 0, trienode.NewWithNodeSet(nodesA), nil)
 	triea, _ = New(TrieID(rootA), dba)
 
 	dbb := NewDatabase(rawdb.NewMemoryDatabase(), nil)
@@ -303,7 +303,7 @@ func TestUnionIterator(t *testing.T) {
 		trieb.MustUpdate([]byte(val.k), []byte(val.v))
 	}
 	rootB, nodesB, _ := trieb.Commit(false)
-	dbb.Update(rootB, types.EmptyLegacyTrieRootHash, 0, trienode.NewWithNodeSet(nodesB), nil)
+	dbb.Update(rootB, types.EmptyZkTrieRootHash, 0, trienode.NewWithNodeSet(nodesB), nil)
 	trieb, _ = New(TrieID(rootB), dbb)
 
 	di, _ := NewUnionIterator([]NodeIterator{triea.MustNodeIterator(nil), trieb.MustNodeIterator(nil)})
@@ -365,7 +365,7 @@ func testIteratorContinueAfterError(t *testing.T, memonly bool, scheme string) {
 		tr.MustUpdate([]byte(val.k), []byte(val.v))
 	}
 	root, nodes, _ := tr.Commit(false)
-	tdb.Update(root, types.EmptyLegacyTrieRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
+	tdb.Update(root, types.EmptyZkTrieRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
 	if !memonly {
 		tdb.Commit(root, false)
 	}
@@ -481,7 +481,7 @@ func testIteratorContinueAfterSeekError(t *testing.T, memonly bool, scheme strin
 			break
 		}
 	}
-	triedb.Update(root, types.EmptyLegacyTrieRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
+	triedb.Update(root, types.EmptyZkTrieRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
 	if !memonly {
 		triedb.Commit(root, false)
 	}
@@ -555,7 +555,7 @@ func testIteratorNodeBlob(t *testing.T, scheme string) {
 		trie.MustUpdate([]byte(val.k), []byte(val.v))
 	}
 	root, nodes, _ := trie.Commit(false)
-	triedb.Update(root, types.EmptyLegacyTrieRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
+	triedb.Update(root, types.EmptyZkTrieRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
 	triedb.Commit(root, false)
 
 	var found = make(map[common.Hash][]byte)
diff --git a/trie/secure_trie_test.go b/trie/secure_trie_test.go
index a4c5f2a502..8772cef048 100644
--- a/trie/secure_trie_test.go
+++ b/trie/secure_trie_test.go
@@ -31,7 +31,7 @@ import (
 )
 
 func newEmptySecure() *StateTrie {
-	trie, _ := NewStateTrie(TrieID(types.EmptyLegacyTrieRootHash), NewDatabase(rawdb.NewMemoryDatabase(), nil))
+	trie, _ := NewStateTrie(TrieID(types.EmptyZkTrieRootHash), NewDatabase(rawdb.NewMemoryDatabase(), nil))
 	return trie
 }
 
@@ -39,7 +39,7 @@ func newEmptySecure() *StateTrie {
 func makeTestStateTrie() (*Database, *StateTrie, map[string][]byte) {
 	// Create an empty trie
 	triedb := NewDatabase(rawdb.NewMemoryDatabase(), nil)
-	trie, _ := NewStateTrie(TrieID(types.EmptyLegacyTrieRootHash), triedb)
+	trie, _ := NewStateTrie(TrieID(types.EmptyZkTrieRootHash), triedb)
 
 	// Fill it with some arbitrary data
 	content := make(map[string][]byte)
diff --git a/trie/sync_test.go b/trie/sync_test.go
index 019de2f6ad..277cb0fb2f 100644
--- a/trie/sync_test.go
+++ b/trie/sync_test.go
@@ -35,7 +35,7 @@ func makeTestTrie(scheme string) (ethdb.Database, *Database, *StateTrie, map[str
 	// Create an empty trie
 	db := rawdb.NewMemoryDatabase()
 	triedb := newTestDatabase(db, scheme)
-	trie, _ := NewStateTrie(TrieID(types.EmptyLegacyTrieRootHash), triedb)
+	trie, _ := NewStateTrie(TrieID(types.EmptyZkTrieRootHash), triedb)
 
 	// Fill it with some arbitrary data
 	content := make(map[string][]byte)
@@ -133,16 +133,18 @@ type trieElement struct {
 func TestEmptySync(t *testing.T) {
 	dbA := newTestDatabase(rawdb.NewMemoryDatabase(), rawdb.HashScheme)
 	dbB := newTestDatabase(rawdb.NewMemoryDatabase(), rawdb.HashScheme)
-	dbC := newTestDatabase(rawdb.NewMemoryDatabase(), rawdb.PathScheme)
-	dbD := newTestDatabase(rawdb.NewMemoryDatabase(), rawdb.PathScheme)
+	// dbC := newTestDatabase(rawdb.NewMemoryDatabase(), rawdb.PathScheme)
+	// dbD := newTestDatabase(rawdb.NewMemoryDatabase(), rawdb.PathScheme)
 
 	emptyA := NewEmpty(dbA)
-	emptyB, _ := New(TrieID(types.EmptyLegacyTrieRootHash), dbB)
-	emptyC := NewEmpty(dbC)
-	emptyD, _ := New(TrieID(types.EmptyLegacyTrieRootHash), dbD)
+	emptyB, _ := New(TrieID(types.EmptyZkTrieRootHash), dbB)
+	// emptyC := NewEmpty(dbC)
+	// emptyD, _ := New(TrieID(types.EmptyLegacyTrieRootHash), dbD)
 
-	for i, trie := range []*Trie{emptyA, emptyB, emptyC, emptyD} {
-		sync := NewSync(trie.Hash(), memorydb.New(), nil, []*Database{dbA, dbB, dbC, dbD}[i].Scheme())
+	// for i, trie := range []*Trie{emptyA, emptyB, emptyC, emptyD} {
+	// sync := NewSync(trie.Hash(), memorydb.New(), nil, []*Database{dbA, dbB, dbC, dbD}[i].Scheme())
+	for i, trie := range []*Trie{emptyA, emptyB} {
+		sync := NewSync(trie.Hash(), memorydb.New(), nil, []*Database{dbA, dbB}[i].Scheme())
 		if paths, nodes, codes := sync.Missing(1); len(paths) != 0 || len(nodes) != 0 || len(codes) != 0 {
 			t.Errorf("test %d: content requested for empty trie: %v, %v, %v", i, paths, nodes, codes)
 		}
@@ -156,10 +158,10 @@ func TestIterativeSync(t *testing.T) {
 	testIterativeSync(t, 100, false, rawdb.HashScheme)
 	testIterativeSync(t, 1, true, rawdb.HashScheme)
 	testIterativeSync(t, 100, true, rawdb.HashScheme)
-	testIterativeSync(t, 1, false, rawdb.PathScheme)
-	testIterativeSync(t, 100, false, rawdb.PathScheme)
-	testIterativeSync(t, 1, true, rawdb.PathScheme)
-	testIterativeSync(t, 100, true, rawdb.PathScheme)
+	// testIterativeSync(t, 1, false, rawdb.PathScheme)
+	// testIterativeSync(t, 100, false, rawdb.PathScheme)
+	// testIterativeSync(t, 1, true, rawdb.PathScheme)
+	// testIterativeSync(t, 100, true, rawdb.PathScheme)
 }
 
 func testIterativeSync(t *testing.T, count int, bypath bool, scheme string) {
@@ -234,7 +236,7 @@ func testIterativeSync(t *testing.T, count int, bypath bool, scheme string) {
 // partial results are returned, and the others sent only later.
 func TestIterativeDelayedSync(t *testing.T) {
 	testIterativeDelayedSync(t, rawdb.HashScheme)
-	testIterativeDelayedSync(t, rawdb.PathScheme)
+	// testIterativeDelayedSync(t, rawdb.PathScheme)
 }
 
 func testIterativeDelayedSync(t *testing.T, scheme string) {
@@ -302,8 +304,8 @@ func testIterativeDelayedSync(t *testing.T, scheme string) {
 func TestIterativeRandomSyncIndividual(t *testing.T) {
 	testIterativeRandomSync(t, 1, rawdb.HashScheme)
 	testIterativeRandomSync(t, 100, rawdb.HashScheme)
-	testIterativeRandomSync(t, 1, rawdb.PathScheme)
-	testIterativeRandomSync(t, 100, rawdb.PathScheme)
+	// testIterativeRandomSync(t, 1, rawdb.PathScheme)
+	// testIterativeRandomSync(t, 100, rawdb.PathScheme)
 }
 
 func testIterativeRandomSync(t *testing.T, count int, scheme string) {
@@ -370,7 +372,7 @@ func testIterativeRandomSync(t *testing.T, count int, scheme string) {
 // partial results are returned (Even those randomly), others sent only later.
 func TestIterativeRandomDelayedSync(t *testing.T) {
 	testIterativeRandomDelayedSync(t, rawdb.HashScheme)
-	testIterativeRandomDelayedSync(t, rawdb.PathScheme)
+	// testIterativeRandomDelayedSync(t, rawdb.PathScheme)
 }
 
 func testIterativeRandomDelayedSync(t *testing.T, scheme string) {
@@ -442,7 +444,7 @@ func testIterativeRandomDelayedSync(t *testing.T, scheme string) {
 // have such references.
 func TestDuplicateAvoidanceSync(t *testing.T) {
 	testDuplicateAvoidanceSync(t, rawdb.HashScheme)
-	testDuplicateAvoidanceSync(t, rawdb.PathScheme)
+	// testDuplicateAvoidanceSync(t, rawdb.PathScheme)
 }
 
 func testDuplicateAvoidanceSync(t *testing.T, scheme string) {
@@ -513,7 +515,7 @@ func testDuplicateAvoidanceSync(t *testing.T, scheme string) {
 // the database.
 func TestIncompleteSyncHash(t *testing.T) {
 	testIncompleteSync(t, rawdb.HashScheme)
-	testIncompleteSync(t, rawdb.PathScheme)
+	// testIncompleteSync(t, rawdb.PathScheme)
 }
 
 func testIncompleteSync(t *testing.T, scheme string) {
@@ -602,7 +604,7 @@ func testIncompleteSync(t *testing.T, scheme string) {
 // depth.
 func TestSyncOrdering(t *testing.T) {
 	testSyncOrdering(t, rawdb.HashScheme)
-	testSyncOrdering(t, rawdb.PathScheme)
+	// testSyncOrdering(t, rawdb.PathScheme)
 }
 
 func testSyncOrdering(t *testing.T, scheme string) {
@@ -736,7 +738,7 @@ func syncWith(t *testing.T, root common.Hash, db ethdb.Database, srcDb *Database
 // states synced in the last cycle.
 func TestSyncMovingTarget(t *testing.T) {
 	testSyncMovingTarget(t, rawdb.HashScheme)
-	testSyncMovingTarget(t, rawdb.PathScheme)
+	// testSyncMovingTarget(t, rawdb.PathScheme)
 }
 
 func testSyncMovingTarget(t *testing.T, scheme string) {
@@ -801,15 +803,15 @@ func testSyncMovingTarget(t *testing.T, scheme string) {
 func TestPivotMove(t *testing.T) {
 	testPivotMove(t, rawdb.HashScheme, true)
 	testPivotMove(t, rawdb.HashScheme, false)
-	testPivotMove(t, rawdb.PathScheme, true)
-	testPivotMove(t, rawdb.PathScheme, false)
+	// testPivotMove(t, rawdb.PathScheme, true)
+	// testPivotMove(t, rawdb.PathScheme, false)
 }
 
 func testPivotMove(t *testing.T, scheme string, tiny bool) {
 	var (
 		srcDisk    = rawdb.NewMemoryDatabase()
 		srcTrieDB  = newTestDatabase(srcDisk, scheme)
-		srcTrie, _ = New(TrieID(types.EmptyLegacyTrieRootHash), srcTrieDB)
+		srcTrie, _ = New(TrieID(types.EmptyZkTrieRootHash), srcTrieDB)
 
 		deleteFn = func(key []byte, tr *Trie, states map[string][]byte) {
 			tr.Delete(key)
diff --git a/trie/trie.go b/trie/trie.go
index 4cb25d5b29..68b39305d2 100644
--- a/trie/trie.go
+++ b/trie/trie.go
@@ -101,7 +101,7 @@ func New(id *ID, db *Database) (*Trie, error) {
 
 // NewEmpty is a shortcut to create empty tree. It's mostly used in tests.
 func NewEmpty(db *Database) *Trie {
-	tr, _ := New(TrieID(types.EmptyLegacyTrieRootHash), db)
+	tr, _ := New(TrieID(types.EmptyZkTrieRootHash), db)
 	return tr
 }
 
diff --git a/trie/trie_reader.go b/trie/trie_reader.go
index 7c46c55368..7cbc782239 100644
--- a/trie/trie_reader.go
+++ b/trie/trie_reader.go
@@ -19,7 +19,6 @@ package trie
 import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/trie/triestate"
 )
 
@@ -46,10 +45,14 @@ type trieReader struct {
 
 // newTrieReader initializes the trie reader with the given node reader.
 func newTrieReader(stateRoot, owner common.Hash, db *Database) (*trieReader, error) {
-	if stateRoot == (common.Hash{}) || stateRoot == types.EmptyLegacyTrieRootHash {
-		if stateRoot == (common.Hash{}) {
-			log.Error("Zero state root hash!")
-		}
+	// if stateRoot == (common.Hash{}) || stateRoot == types.EmptyRootHash {
+	// 	if stateRoot == (common.Hash{}) {
+	// 		log.Error("Zero state root hash!")
+	// 	}
+	// 	return &trieReader{owner: owner}, nil
+	// }
+	if stateRoot == types.EmptyZkTrieRootHash {
+		// log.Error("Zero state root hash!")
 		return &trieReader{owner: owner}, nil
 	}
 	reader, err := db.Reader(stateRoot)