[DO NOT MERGE] Verkle Gen Devnet 6

cmd/state/commands/state_root.go

@@ -108,7 +108,7 @@ func StateRoot(ctx context.Context, genesis *types.Genesis, blockNum uint64, dat
 	if rwTx, err = db.BeginRw(ctx); err != nil {
 		return err
 	}
-	_, genesisIbs, err4 := core.GenesisToBlock(genesis, "")
+	_, genesisIbs, err4 := core.GenesisToBlock(genesis, "", nil)
 	if err4 != nil {
 		return err4
 	}

cmd/state/exec3/state.go

@@ -143,7 +143,7 @@ func (rw *Worker) RunTxTaskNoLock(txTask *exec22.TxTask) {
 		if txTask.BlockNum == 0 {
 			// Genesis block
 			// fmt.Printf("txNum=%d, blockNum=%d, Genesis\n", txTask.TxNum, txTask.BlockNum)
-			_, ibs, err = core.GenesisToBlock(rw.genesis, "")
+			_, ibs, err = core.GenesisToBlock(rw.genesis, "", nil)
 			if err != nil {
 				panic(err)
 			}

cmd/state/exec3/state_recon.go

@@ -297,7 +297,7 @@ func (rw *ReconWorker) runTxTask(txTask *exec22.TxTask) error {
 	if txTask.BlockNum == 0 && txTask.TxIndex == -1 {
 		//fmt.Printf("txNum=%d, blockNum=%d, Genesis\n", txTask.TxNum, txTask.BlockNum)
 		// Genesis block
-		_, ibs, err = core.GenesisToBlock(rw.genesis, "")
+		_, ibs, err = core.GenesisToBlock(rw.genesis, "", nil)
 		if err != nil {
 			return err
 		}

cmd/verkle/verkletrie/incrementAccount.go

@@ -34,11 +34,11 @@ func IncrementAccount(vTx kv.RwTx, tx kv.Tx, workers uint64, verkleWriter *Verkl
 	}
 	defer cancelWorkers()
 
-	accountCursor, err := tx.CursorDupSort(kv.AccountChangeSet)
+	accChangesCursor, err := tx.CursorDupSort(kv.AccountChangeSet)
 	if err != nil {
 		return err
 	}
-	defer accountCursor.Close()
+	defer accChangesCursor.Close()
 
 	// Start Goroutine for collection
 	go func() {
@@ -62,7 +62,7 @@ func IncrementAccount(vTx kv.RwTx, tx kv.Tx, workers uint64, verkleWriter *Verkl
 	marker := NewVerkleMarker(tmpdir)
 	defer marker.Rollback()
 
-	for k, v, err := accountCursor.Seek(hexutility.EncodeTs(from)); k != nil; k, v, err = accountCursor.Next() {
+	for k, v, err := accChangesCursor.Seek(hexutility.EncodeTs(from)); k != nil; k, v, err = accChangesCursor.Next() {
 		if err != nil {
 			return err
 		}

cmd/verkle/verkletrie/verkle_tree_writer.go

@@ -16,7 +16,7 @@ import (
 	"github.com/ledgerwatch/erigon/common"
 	"github.com/ledgerwatch/erigon/core/rawdb"
 	"github.com/ledgerwatch/erigon/core/types/accounts"
-	"github.com/ledgerwatch/erigon/turbo/trie/vtree"
+	"github.com/ledgerwatch/erigon/turbo/trie/vkutils"
 )
 
 func int256ToVerkleFormat(x *uint256.Int, buffer []byte) {
@@ -30,48 +30,71 @@ func int256ToVerkleFormat(x *uint256.Int, buffer []byte) {
 
 func flushVerkleNode(db kv.RwTx, node verkle.VerkleNode, logInterval *time.Ticker, key []byte, logger log.Logger) error {
 	var err error
-	totalInserted := 0
-	node.(*verkle.InternalNode).Flush(func(node verkle.VerkleNode) {
-		if err != nil {
-			return
-		}
+	// totalInserted := 0
+	// node.(*verkle.InternalNode).Flush(func(node verkle.VerkleNode) {
+	// 	if err != nil {
+	// 		return
+	// 	}
 
-		err = rawdb.WriteVerkleNode(db, node)
+	// 	err = rawdb.WriteVerkleNode(db, node)
+	// 	if err != nil {
+	// 		return
+	// 	}
+	// 	totalInserted++
+	// 	select {
+	// 	case <-logInterval.C:
+	// 		logger.Info("Flushing Verkle nodes", "inserted", totalInserted, "key", common.Bytes2Hex(key))
+	// 	default:
+	// 	}
+	// })
+
+	node.(*verkle.InternalNode).Flush(func(path []byte, node verkle.VerkleNode) {
+		node.Commit()
+		s, err := node.Serialize()
 		if err != nil {
-			return
+			panic(err)
 		}
-		totalInserted++
-		select {
-		case <-logInterval.C:
-			logger.Info("Flushing Verkle nodes", "inserted", totalInserted, "key", common.Bytes2Hex(key))
-		default:
+		if err := db.Put(kv.VerkleTrie, path, s); err != nil {
+			panic(err)
 		}
 	})
 	return err
 }
 
 func collectVerkleNode(collector *etl.Collector, node verkle.VerkleNode, logInterval *time.Ticker, key []byte, logger log.Logger) error {
 	var err error
-	totalInserted := 0
-	node.(*verkle.InternalNode).Flush(func(node verkle.VerkleNode) {
-		if err != nil {
-			return
-		}
-		var encodedNode []byte
+	// totalInserted := 0
+	// node.(*verkle.InternalNode).Flush(func(node verkle.VerkleNode) {
+	// 	if err != nil {
+	// 		return
+	// 	}
+	// 	var encodedNode []byte
+
+	// 	rootHash := node.Commitment().Bytes()
+	// 	encodedNode, err = node.Serialize()
+	// 	if err != nil {
+	// 		return
+	// 	}
+	// 	err = collector.Collect(rootHash[:], encodedNode)
+	// 	totalInserted++
+	// 	select {
+	// 	case <-logInterval.C:
+	// 		logger.Info("Flushing Verkle nodes", "inserted", totalInserted, "key", common.Bytes2Hex(key))
+	// 	default:
+	// 	}
+	// })
 
-		rootHash := node.Commitment().Bytes()
-		encodedNode, err = node.Serialize()
+	node.(*verkle.InternalNode).Flush(func(path []byte, node verkle.VerkleNode) {
+		node.Commit()
+		s, err := node.Serialize()
 		if err != nil {
-			return
+			panic(err)
 		}
-		err = collector.Collect(rootHash[:], encodedNode)
-		totalInserted++
-		select {
-		case <-logInterval.C:
-			logger.Info("Flushing Verkle nodes", "inserted", totalInserted, "key", common.Bytes2Hex(key))
-		default:
+		if err := collector.Collect(path, s); err != nil {
+			panic(err)
 		}
 	})
+
 	return err
 }
 
@@ -100,10 +123,10 @@ func (v *VerkleTreeWriter) UpdateAccount(versionKey []byte, codeSize uint64, isC
 	copy(nonceKey[:], versionKey[:31])
 	copy(balanceKey[:], versionKey[:31])
 	copy(codeSizeKey[:], versionKey[:31])
-	codeHashKey[31] = vtree.CodeKeccakLeafKey
-	nonceKey[31] = vtree.NonceLeafKey
-	balanceKey[31] = vtree.BalanceLeafKey
-	codeSizeKey[31] = vtree.CodeSizeLeafKey
+	codeHashKey[31] = vkutils.CodeKeccakLeafKey
+	nonceKey[31] = vkutils.NonceLeafKey
+	balanceKey[31] = vkutils.BalanceLeafKey
+	codeSizeKey[31] = vkutils.CodeSizeLeafKey
 	// Process values
 	int256ToVerkleFormat(&acc.Balance, balance[:])
 	binary.LittleEndian.PutUint64(nonce[:], acc.Nonce)
@@ -139,10 +162,10 @@ func (v *VerkleTreeWriter) DeleteAccount(versionKey []byte, isContract bool) err
 	copy(nonceKey[:], versionKey[:31])
 	copy(balanceKey[:], versionKey[:31])
 	copy(codeSizeKey[:], versionKey[:31])
-	codeHashKey[31] = vtree.CodeKeccakLeafKey
-	nonceKey[31] = vtree.NonceLeafKey
-	balanceKey[31] = vtree.BalanceLeafKey
-	codeSizeKey[31] = vtree.CodeSizeLeafKey
+	codeHashKey[31] = vkutils.CodeKeccakLeafKey
+	nonceKey[31] = vkutils.NonceLeafKey
+	balanceKey[31] = vkutils.BalanceLeafKey
+	codeSizeKey[31] = vkutils.CodeSizeLeafKey
 	// Insert in the tree
 	if err := v.collector.Collect(versionKey, []byte{0}); err != nil {
 		return err
@@ -194,31 +217,32 @@ func (v *VerkleTreeWriter) CommitVerkleTreeFromScratch() (libcommon.Hash, error)
 	root := verkle.New()
 
 	logInterval := time.NewTicker(30 * time.Second)
-	if err := v.collector.Load(v.db, kv.VerkleTrie, func(k []byte, val []byte, _ etl.CurrentTableReader, next etl.LoadNextFunc) error {
-		if len(val) == 0 {
-			return next(k, nil, nil)
-		}
-		if err := root.InsertOrdered(libcommon.CopyBytes(k), libcommon.CopyBytes(val), func(node verkle.VerkleNode) {
-			rootHash := node.Commitment().Bytes()
-			encodedNode, err := node.Serialize()
-			if err != nil {
-				panic(err)
-			}
-			if err := verkleCollector.Collect(rootHash[:], encodedNode); err != nil {
-				panic(err)
-			}
-			select {
-			case <-logInterval.C:
-				v.logger.Info("[Verkle] Assembling Verkle Tree", "key", common.Bytes2Hex(k))
-			default:
-			}
-		}); err != nil {
-			return err
-		}
-		return next(k, nil, nil)
-	}, etl.TransformArgs{Quit: context.Background().Done()}); err != nil {
-		return libcommon.Hash{}, err
-	}
+	// if err := v.collector.Load(v.db, kv.VerkleTrie, func(k []byte, val []byte, _ etl.CurrentTableReader, next etl.LoadNextFunc) error {
+	// 	if len(val) == 0 {
+	// 		return next(k, nil, nil)
+	// 	}
+	// if err := root.Insert(libcommon.CopyBytes(k), libcommon.CopyBytes(val),
+	// func(node verkle.VerkleNode) {
+	// 	rootHash := node.Commitment().Bytes()
+	// 	encodedNode, err := node.Serialize()
+	// 	if err != nil {
+	// 		panic(err)
+	// 	}
+	// 	if err := verkleCollector.Collect(rootHash[:], encodedNode); err != nil {
+	// 		panic(err)
+	// 	}
+	// 	select {
+	// 	case <-logInterval.C:
+	// 		v.logger.Info("[Verkle] Assembling Verkle Tree", "key", common.Bytes2Hex(k))
+	// 	default:
+	// 	}
+	// }); err != nil {
+	// 	return err
+	// }
+	// return next(k, nil, nil)
+	// }, etl.TransformArgs{Quit: context.Background().Done()}); err != nil {
+	// return libcommon.Hash{}, err
+	// }
 
 	// Flush the rest all at once
 	if err := collectVerkleNode(v.collector, root, logInterval, nil, v.logger); err != nil {

cmd/verkle/verkletrie/workers.go

@@ -7,7 +7,7 @@ import (
 	libcommon "github.com/ledgerwatch/erigon-lib/common"
 
 	"github.com/ledgerwatch/erigon/core/types/accounts"
-	"github.com/ledgerwatch/erigon/turbo/trie/vtree"
+	"github.com/ledgerwatch/erigon/turbo/trie/vkutils"
 )
 
 type regeneratePedersenAccountsJob struct {
@@ -83,7 +83,7 @@ func pedersenAccountWorker(ctx context.Context, logPrefix string, in chan *regen
 
 		// prevent sending to close channel
 		out <- &regeneratePedersenAccountsOut{
-			versionHash: libcommon.BytesToHash(vtree.GetTreeKeyVersion(job.address[:])),
+			versionHash: libcommon.BytesToHash(vkutils.GetTreeKeyVersion(job.address[:])),
 			account:     job.account,
 			address:     job.address,
 			codeSize:    job.codeSize,
@@ -107,7 +107,7 @@ func pedersenStorageWorker(ctx context.Context, logPrefix string, in, out chan *
 			return
 		}
 		out <- &regeneratePedersenStorageJob{
-			storageVerkleKey: libcommon.BytesToHash(vtree.GetTreeKeyStorageSlot(job.address[:], job.storageKey)),
+			storageVerkleKey: libcommon.BytesToHash(vkutils.GetTreeKeyStorageSlot(job.address[:], job.storageKey)),
 			storageKey:       job.storageKey,
 			address:          job.address,
 			storageValue:     job.storageValue,
@@ -142,15 +142,15 @@ func pedersenCodeWorker(ctx context.Context, logPrefix string, in chan *regenera
 			}
 		}
 		// Chunkify contract code and build keys for each chunks and insert them in the tree
-		chunkedCode := vtree.ChunkifyCode(job.code)
+		chunkedCode := vkutils.ChunkifyCode(job.code)
 		offset := byte(0)
 		offsetOverflow := false
-		currentKey := vtree.GetTreeKeyCodeChunk(job.address[:], uint256.NewInt(0))
+		currentKey := vkutils.GetTreeKeyCodeChunk(job.address[:], uint256.NewInt(0))
 		// Write code chunks
 		for i := 0; i < len(chunkedCode); i += 32 {
 			chunks = append(chunks, libcommon.CopyBytes(chunkedCode[i:i+32]))
 			if currentKey[31]+offset < currentKey[31] || offsetOverflow {
-				currentKey = vtree.GetTreeKeyCodeChunk(job.address[:], uint256.NewInt(uint64(i)/32))
+				currentKey = vkutils.GetTreeKeyCodeChunk(job.address[:], uint256.NewInt(uint64(i)/32))
 				chunkKeys = append(chunkKeys, libcommon.CopyBytes(currentKey))
 				offset = 1
 				offsetOverflow = false
@@ -187,7 +187,7 @@ func incrementalAccountWorker(ctx context.Context, logPrefix string, in chan *re
 		case <-ctx.Done():
 			return
 		}
-		versionKey := libcommon.BytesToHash(vtree.GetTreeKeyVersion(job.address[:]))
+		versionKey := libcommon.BytesToHash(vkutils.GetTreeKeyVersion(job.address[:]))
 		if job.absentInState {
 			out <- &regenerateIncrementalPedersenAccountsOut{
 				versionHash:   versionKey[:],
@@ -200,16 +200,16 @@ func incrementalAccountWorker(ctx context.Context, logPrefix string, in chan *re
 		var chunks [][]byte
 		var chunkKeys [][]byte
 		// Chunkify contract code and build keys for each chunks and insert them in the tree
-		chunkedCode := vtree.ChunkifyCode(job.code)
+		chunkedCode := vkutils.ChunkifyCode(job.code)
 		offset := byte(0)
 		offsetOverflow := false
-		currentKey := vtree.GetTreeKeyCodeChunk(job.address[:], uint256.NewInt(0))
+		currentKey := vkutils.GetTreeKeyCodeChunk(job.address[:], uint256.NewInt(0))
 		// Write code chunks
 		for i := 0; i < len(chunkedCode); i += 32 {
 			chunks = append(chunks, libcommon.CopyBytes(chunkedCode[i:i+32]))
 			codeKey := libcommon.CopyBytes(currentKey)
 			if currentKey[31]+offset < currentKey[31] || offsetOverflow {
-				currentKey = vtree.GetTreeKeyCodeChunk(job.address[:], uint256.NewInt(uint64(i)/32))
+				currentKey = vkutils.GetTreeKeyCodeChunk(job.address[:], uint256.NewInt(uint64(i)/32))
 				chunkKeys = append(chunkKeys, codeKey)
 				offset = 1
 				offsetOverflow = false

common/paths/paths.go

@@ -98,7 +98,8 @@ func DataDirForNetwork(datadir string, network string) string {
 		return networkDataDirCheckingLegacy(datadir, "gnosis")
 	case networkname.ChiadoChainName:
 		return networkDataDirCheckingLegacy(datadir, "chiado")
-
+	case networkname.VerkleGenDevnet2:
+		return networkDataDirCheckingLegacy(datadir, "verkle-gen-devnet2")
 	default:
 		return datadir
 	}

consensus/aura/aura_test.go

@@ -24,7 +24,7 @@ import (
 func TestEmptyBlock(t *testing.T) {
 	require := require.New(t)
 	genesis := core.GnosisGenesisBlock()
-	genesisBlock, _, err := core.GenesisToBlock(genesis, "")
+	genesisBlock, _, err := core.GenesisToBlock(genesis, "", nil)
 	require.NoError(err)
 
 	genesis.Config.TerminalTotalDifficultyPassed = false

consensus/ethash/consensus.go

@@ -29,6 +29,7 @@ import (
 	"github.com/ledgerwatch/erigon-lib/chain"
 	libcommon "github.com/ledgerwatch/erigon-lib/common"
 	"github.com/ledgerwatch/erigon/consensus/ethash/ethashcfg"
+	"github.com/ledgerwatch/erigon/turbo/trie/vkutils"
 	"github.com/ledgerwatch/log/v3"
 	"golang.org/x/crypto/sha3"
 
@@ -668,5 +669,11 @@ func accumulateRewards(config *chain.Config, state *state.IntraBlockState, heade
 			state.AddBalance(uncle.Coinbase, &uncleRewards[i])
 		}
 	}
+	if config.IsPrague(header.Time) {
+		state.Witness().TouchAddressOnReadAndComputeGas(header.Coinbase.Bytes(), uint256.Int{}, vkutils.BalanceLeafKey)
+		state.Witness().TouchAddressOnReadAndComputeGas(header.Coinbase.Bytes(), uint256.Int{}, vkutils.VersionLeafKey)
+		state.Witness().TouchAddressOnReadAndComputeGas(header.Coinbase.Bytes(), uint256.Int{}, vkutils.NonceLeafKey)
+		state.Witness().TouchAddressOnReadAndComputeGas(header.Coinbase.Bytes(), uint256.Int{}, vkutils.CodeKeccakLeafKey)
+	}
 	state.AddBalance(header.Coinbase, &minerReward)
 }