feat: enable KromaZKTrie by default

cmd/geth/config.go

@@ -190,7 +190,7 @@ func makeFullNode(ctx *cli.Context) (*node.Node, ethapi.Backend) {
 	}
 
 	cfg.Eth.CircuitParams = new(params.CircuitParams)
-	cfg.Eth.ExperimentalZkTree = ctx.Bool(utils.ExperimentalZkTrie.Name)
+	cfg.Eth.KromaZKTrie = ctx.Bool(utils.KromaZKTrie.Name)
 	if ctx.IsSet(utils.MaxTxsFlag.Name) {
 		maxTxs := ctx.Int(utils.MaxTxsFlag.Name)
 		cfg.Eth.CircuitParams.MaxTxs = &maxTxs

cmd/geth/main.go

@@ -157,7 +157,7 @@ var (
 		// [kroma unsupported]
 		// utils.RollupHaltOnIncompatibleProtocolVersionFlag,
 		// utils.RollupSuperchainUpgradesFlag,
-		utils.ExperimentalZkTrie,
+		utils.KromaZKTrie,
 		configFileFlag,
 	}, utils.NetworkFlags, utils.DatabaseFlags)
 

cmd/utils/flags.go

@@ -1036,10 +1036,11 @@ Please note that --` + MetricsHTTPFlag.Name + ` must be set to start the server.
 		Category: flags.MetricsCategory,
 	}
 
-	ExperimentalZkTrie = &cli.BoolFlag{
-		Name:     "zkstatetrie",
-		Usage:    "use ZkMerkleStateTrie instead of ZkTrie in state. This is an experimental flag.",
+	KromaZKTrie = &cli.BoolFlag{
+		Name:     "KromaZKTrie",
+		Usage:    "use ZkMerkleStateTrie instead of ZkTrie in state.",
 		Category: flags.EthCategory,
+		Value:    true,
 	}
 )
 

core/blockchain.go

@@ -151,12 +151,12 @@ type CacheConfig struct {
 	SnapshotNoBuild bool // Whether the background generation is allowed
 	SnapshotWait    bool // Wait for snapshot construction on startup. TODO(karalabe): This is a dirty hack for testing, nuke it
 
-	ExperimentalZkTrie bool // use ZkMerkleStateTrie instead of ZkTrie
+	KromaZKTrie bool // use ZkMerkleStateTrie instead of ZkTrie
 }
 
 // triedbConfig derives the configures for trie database.
 func (c *CacheConfig) triedbConfig() *trie.Config {
-	config := &trie.Config{Preimages: c.Preimages, ExperimentalZkTrie: c.ExperimentalZkTrie}
+	config := &trie.Config{Preimages: c.Preimages, KromaZKTrie: c.KromaZKTrie}
 	if c.StateScheme == rawdb.HashScheme {
 		config.HashDB = &hashdb.Config{
 			CleanCacheSize: c.TrieCleanLimit * 1024 * 1024,

core/state/database.go

@@ -176,7 +176,7 @@ type cachingDB struct {
 
 // OpenTrie opens the main account trie at a specific root hash.
 func (db *cachingDB) OpenTrie(root common.Hash) (Trie, error) {
-	if db.triedb.IsZkStateTrie() {
+	if db.triedb.IsKromaZK() {
 		return trie.NewZkMerkleStateTrie(root, db.triedb)
 	}
 	// [Scroll: START]
@@ -197,7 +197,7 @@ func (db *cachingDB) OpenTrie(root common.Hash) (Trie, error) {
 
 // OpenStorageTrie opens the storage trie of an account.
 func (db *cachingDB) OpenStorageTrie(stateRoot common.Hash, address common.Address, root common.Hash) (Trie, error) {
-	if db.triedb.IsZkStateTrie() {
+	if db.triedb.IsKromaZK() {
 		return trie.NewZkMerkleStateTrie(root, db.triedb)
 	}
 	// [Scroll: START]

eth/backend.go

@@ -208,7 +208,7 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) {
 			// [Scroll: START]
 			MPTWitness: config.MPTWitness,
 			// [Scroll: END]
-			ExperimentalZkTrie: config.ExperimentalZkTree,
+			KromaZKTrie: config.KromaZKTrie,
 		}
 	)
 	// Override the chain config with provided settings.

eth/ethconfig/config.go

@@ -190,7 +190,7 @@ type Config struct {
 	// [Scroll: END]
 	CircuitParams *params.CircuitParams
 
-	ExperimentalZkTree bool
+	KromaZKTrie bool
 }
 
 // CreateConsensusEngine creates a consensus engine for the given chain config.

internal/ethapi/api.go

@@ -787,7 +787,7 @@ func (s *BlockChainAPI) GetProof(ctx context.Context, address common.Address, st
 }
 
 func (s *BlockChainAPI) newStateTrie(id *trie.ID, db *trie.Database) (state.Trie, error) {
-	if db.IsZkStateTrie() {
+	if db.IsKromaZK() {
 		return trie.NewZkMerkleStateTrie(id.Root, db)
 	}
 	if db.IsZk() {

miner/payload_building.go

@@ -234,7 +234,13 @@ func (w *worker) buildPayload(args *BuildPayloadArgs) (*Payload, error) {
 		// Setup the timer for terminating the process if SECONDS_PER_SLOT (12s in
 		// the Mainnet configuration) have passed since the point in time identified
 		// by the timestamp parameter.
-		endTimer := time.NewTimer(time.Second * 12)
+
+		// KROMA has a blocktime of 2 seconds, so we fixed it.
+		endTime := time.Second * 2
+		if w.chainConfig.Kroma == nil {
+			endTime = time.Second * 12
+		}
+		endTimer := time.NewTimer(endTime)
 
 		fullParams := &generateParams{
 			timestamp:   args.Timestamp,

trie/database.go

@@ -37,7 +37,7 @@ type Config struct {
 	PathDB    *pathdb.Config // Configs for experimental path-based scheme
 	Zktrie    bool           // use zktrie
 
-	ExperimentalZkTrie bool // use zktree
+	KromaZKTrie bool // use zktree
 }
 
 // HashDefaults represents a config for using hash-based scheme with
@@ -378,19 +378,19 @@ func (db *Database) Get(key []byte) ([]byte, error) {
 	return zdb.Get(key)
 }
 
-func (db *Database) IsZk() bool          { return db.config.Zktrie }
-func (db *Database) IsZkStateTrie() bool { return db.config.Zktrie && db.config.ExperimentalZkTrie }
+func (db *Database) IsZk() bool      { return db.config.Zktrie }
+func (db *Database) IsKromaZK() bool { return db.config.Zktrie && db.config.KromaZKTrie }
 
 func (db *Database) SetBackend(isZk bool) {
 	if db.config.Zktrie == isZk {
 		return
 	}
 	db.config = &Config{
-		Preimages:          db.config.Preimages,
-		HashDB:             db.config.HashDB,
-		PathDB:             db.config.PathDB,
-		Zktrie:             isZk,
-		ExperimentalZkTrie: db.config.ExperimentalZkTrie,
+		Preimages:   db.config.Preimages,
+		HashDB:      db.config.HashDB,
+		PathDB:      db.config.PathDB,
+		Zktrie:      isZk,
+		KromaZKTrie: db.config.KromaZKTrie,
 	}
 	if db.config.PathDB != nil {
 		if isZk {

trie/iterator.go

@@ -859,7 +859,7 @@ func zkMerkleTreeNodeBlobFunctions(findBlobByHash func(key []byte) ([]byte, erro
 				return &merkleTreeIteratorLeafNode{
 					hash: hash,
 					blob: n.Data(),
-					key:  zkt.ReverseByteOrder(n.Key),
+					key:  BytesToZkIteratorKey(n.Key).Bytes(),
 				}, nil
 			}
 			return nil, nil
@@ -899,7 +899,7 @@ func zktrieNodeBlobFunctions(t *zktrie.ZkTrie) (
 				return &merkleTreeIteratorLeafNode{
 					hash: hash,
 					blob: node.Data(),
-					key:  node.NodeKey.Bytes(),
+					key:  BytesToZkIteratorKey(node.NodeKey[:]).Bytes(),
 				}, nil
 			}
 			return nil, nil
@@ -933,6 +933,7 @@ func (it *merkleTreeIterator) seek(path []byte) {
 	if len(path) == 0 {
 		return
 	}
+	path = zk.NewTreePathFromHashBig(common.BytesToHash(path))
 
 	for _, p := range path {
 		if parent, ok := it.stack[len(it.stack)-1].(*merkleTreeIteratorParentNode); ok {

trie/iterator_key.go

@@ -0,0 +1,26 @@
+package trie
+
+import (
+	zkt "github.com/kroma-network/zktrie/types"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/trie/zk"
+)
+
+// File for defining an iterator key and managing key <-> iterator key conversion functions.
+//
+// NodeIterator.LeafKey must satisfy the following characteristics
+// ```
+// preordertraversal(tree).filter(x -> x is leaf).map(x -> x.leafKey) == sort(leafKeys)
+// ```
+// Since Trie satisfies this condition, functions that utilize it do not require any additional code (e.g. snapsync).
+// However, zktrie does not, so unless we introduce a new key concept, we need to modify the core source code quite a bit.
+// Therefore, we introduced the concept of iteratorKey, which satisfies the above condition, and implemented functions to convert key and iteratorKey.
+
+func BytesToZkIteratorKey(data []byte) common.Hash {
+	return common.BigToHash(zk.NewTreePathFromBytes(data).ToBigInt())
+}
+
+func ZkIteratorKeyToZkHash(key common.Hash) zkt.Hash {
+	return *zk.NewTreePathFromHashBig(key).ToZkHash()
+}

trie/iterator_test.go

@@ -628,7 +628,7 @@ func TestMerkleTreeIterator(t *testing.T) {
 			db.Delete(zkt.ReverseByteOrder(it.Hash().Bytes()))
 			if it.Leaf() {
 				leafCount++
-				leafPath := zk.NewTreePathFromHash(common.BytesToHash(it.LeafKey()))
+				leafPath := zk.NewTreePathFromHashBig(common.BytesToHash(it.LeafKey()))
 				if !bytes.Equal(it.Path(), leafPath[:len(it.Path())]) {
 					t.Errorf("incorrect tree path. iterator path : %v, leaf path %v", it.Path(), leafPath)
 				}
@@ -670,7 +670,7 @@ func TestMerkleTreeIterator(t *testing.T) {
 		var inputs []*kvs
 		for _, data := range testdata1 {
 			hash := zk.MustNewSecureHash(common.LeftPadBytes([]byte(data.k), 32))
-			inputs = append(inputs, &kvs{k: string(zk.NewTreePathFromZkHash(*hash)), v: data.v})
+			inputs = append(inputs, &kvs{k: string(BytesToZkIteratorKey(hash[:]).Bytes()), v: data.v})
 		}
 		slices.SortFunc(inputs, func(a, b *kvs) int { return bytes.Compare([]byte(a.k), []byte(b.k)) })
 		for idx := 0; idx < len(inputs); idx++ {

trie/merkle_trie.go

@@ -80,7 +80,7 @@ type MerkleStateTrie interface {
 }
 
 func NewMerkleStateTrie(id *ID, db *Database) (MerkleStateTrie, error) {
-	if db.IsZkStateTrie() {
+	if db.IsKromaZK() {
 		return NewZkMerkleStateTrie(id.Root, db)
 	}
 	if db.IsZk() {

trie/zk/merkle_tree.go

@@ -247,7 +247,7 @@ func (t *MerkleTree) MustDelete(key []byte) {
 // mt.ImportDumpedLeafs), but this will lose all the Root history of the MerkleTree
 func (t *MerkleTree) Delete(key []byte) error {
 	node, path, pathNodes := t.rootNode, t.newTreePath(key), *new([]*ParentNode)
-	for _, p := range path {
+	for lvl, p := range path {
 		switch n := node.(type) {
 		case *ParentNode:
 			pathNodes = append(pathNodes, n)
@@ -261,7 +261,7 @@ func (t *MerkleTree) Delete(key []byte) error {
 		case *EmptyNode:
 			return trie.ErrKeyNotFound
 		case *HashNode:
-			return trie.ErrKeyNotFound
+			return fmt.Errorf("Delete: encounter hash node. level %d, path %v", lvl, path[:lvl])
 		default:
 			return trie.ErrInvalidNodeFound
 		}
@@ -336,7 +336,8 @@ func (t *MerkleTree) Prove(key []byte, writeNode func(TreeNode) error) error {
 		return err
 	}
 	node := t.rootNode
-	for _, p := range t.newTreePath(key) {
+	path := t.newTreePath(key)
+	for lvl, p := range path {
 		// TODO: notice here we may have broken some implicit on the proofDb:
 		// the key is not keccak(value) and it even can not be derived from the value by any means without an actual decoding
 		if err := writeNode(node); err != nil {
@@ -350,7 +351,7 @@ func (t *MerkleTree) Prove(key []byte, writeNode func(TreeNode) error) error {
 		case *EmptyNode:
 			return nil
 		case *HashNode:
-			return nil
+			return fmt.Errorf("Prove: encounter hash node. level %d, path %v", lvl, path[:lvl])
 		default:
 			return trie.ErrInvalidNodeFound
 		}

trie/zk/tree_path.go

@@ -1,6 +1,8 @@
 package zk
 
 import (
+	"math/big"
+
 	zkt "github.com/kroma-network/zktrie/types"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -14,6 +16,22 @@ const (
 	right = byte(1)
 )
 
+func NewTreePathFromHashBig(hash common.Hash) TreePath {
+	return NewTreePathFromBig(hash.Big(), len(hash)*8)
+}
+
+func NewTreePathFromBig(key *big.Int, maxLevel int) TreePath {
+	result := make([]byte, maxLevel)
+	for i := 0; i < maxLevel; i++ {
+		bit := new(big.Int).Mod(key, common.Big2)
+		if bit.Uint64() == 1 {
+			result[maxLevel-1-i] = byte(bit.Int64())
+		}
+		key.Rsh(key, 1)
+	}
+	return result
+}
+
 func NewTreePathFromHash(hash common.Hash) TreePath {
 	return NewTreePathFromBytesAndMaxLevel(zkt.ReverseByteOrder(hash[:]), len(hash)*8)
 }
@@ -65,3 +83,12 @@ func (p TreePath) toHexBytes() []byte {
 	}
 	return bytes
 }
+
+func (p TreePath) ToBigInt() *big.Int {
+	result := new(big.Int)
+	lastIdx := len(p) - 1
+	for i, b := range p {
+		result.SetBit(result, lastIdx-i, uint(b))
+	}
+	return result
+}