chore: swap prague for verkle. (#467)

.github/workflows/conversion.yml

@@ -29,7 +29,7 @@ jobs:
         run: go run ./cmd/geth --dev --cache.preimages init genesis.json
 
       - name: Run geth in devmode
-        run: go run ./cmd/geth --dev --dev.period=5 --cache.preimages --http --datadir=.shadowfork --override.overlay-stride=10 --override.prague=$(($(date +%s) + 45)) --http.api=debug &
+        run: go run ./cmd/geth --dev --dev.period=5 --cache.preimages --http --datadir=.shadowfork --override.overlay-stride=10 --override.verkle=$(($(date +%s) + 45)) --http.api=debug &
 
       - name: Wait for the transition to start
         run: |

cmd/evm/internal/t8ntool/execution.go

@@ -163,7 +163,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		return h
 	}
 	var (
-		statedb     = MakePreState(rawdb.NewMemoryDatabase(), chainConfig, pre, chainConfig.IsPrague(big.NewInt(int64(pre.Env.Number)), pre.Env.Timestamp))
+		statedb     = MakePreState(rawdb.NewMemoryDatabase(), chainConfig, pre, chainConfig.IsVerkle(big.NewInt(int64(pre.Env.Number)), pre.Env.Timestamp))
 		vtrpre      *trie.VerkleTrie
 		signer      = types.MakeSigner(chainConfig, new(big.Int).SetUint64(pre.Env.Number), pre.Env.Timestamp)
 		gaspool     = new(core.GasPool)
@@ -225,7 +225,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		chainConfig.DAOForkBlock.Cmp(new(big.Int).SetUint64(pre.Env.Number)) == 0 {
 		misc.ApplyDAOHardFork(statedb)
 	}
-	if chainConfig.IsPrague(big.NewInt(int64(pre.Env.Number)), pre.Env.Timestamp) {
+	if chainConfig.IsVerkle(big.NewInt(int64(pre.Env.Number)), pre.Env.Timestamp) {
 		// insert the parent hash in the contract
 		parentNum := pre.Env.Number - 1
 		core.ProcessParentBlockHash(statedb, parentNum, pre.Env.BlockHashes[math.HexOrDecimal64(parentNum)])
@@ -345,7 +345,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		amount := new(big.Int).Mul(new(big.Int).SetUint64(w.Amount), big.NewInt(params.GWei))
 		statedb.AddBalance(w.Address, amount)
 	}
-	if chainConfig.IsPrague(big.NewInt(int64(pre.Env.Number)), pre.Env.Timestamp) {
+	if chainConfig.IsVerkle(big.NewInt(int64(pre.Env.Number)), pre.Env.Timestamp) {
 		if err := overlay.OverlayVerkleTransition(statedb, common.Hash{}, chainConfig.OverlayStride); err != nil {
 			return nil, nil, fmt.Errorf("error performing the transition, err=%w", err)
 		}
@@ -359,7 +359,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 	// Add the witness to the execution result
 	var vktProof *verkle.VerkleProof
 	var vktStateDiff verkle.StateDiff
-	if chainConfig.IsPrague(big.NewInt(int64(pre.Env.Number)), pre.Env.Timestamp) {
+	if chainConfig.IsVerkle(big.NewInt(int64(pre.Env.Number)), pre.Env.Timestamp) {
 		keys := statedb.Witness().Keys()
 		if len(keys) > 0 && vtrpre != nil {
 			var proofTrie *trie.VerkleTrie
@@ -400,7 +400,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		execRs.CurrentExcessBlobGas = (*math.HexOrDecimal64)(vmContext.ExcessBlobGas)
 		execRs.CurrentBlobGasUsed = (*math.HexOrDecimal64)(&blobGasUsed)
 	}
-	if chainConfig.IsPrague(big.NewInt(int64(pre.Env.Number)), pre.Env.Timestamp) {
+	if chainConfig.IsVerkle(big.NewInt(int64(pre.Env.Number)), pre.Env.Timestamp) {
 		sdb := statedb.Database()
 		ended := sdb.Transitioned()
 		if !ended {
@@ -482,7 +482,7 @@ func MakePreState(db ethdb.Database, chainConfig *params.ChainConfig, pre *Prest
 		// start the conversion on the first block
 		log.Info("starting verkle transition?", "in transition", sdb.InTransition(), "transitioned", sdb.Transitioned(), "mpt root", mptRoot)
 		if !sdb.InTransition() && !sdb.Transitioned() {
-			sdb.StartVerkleTransition(mptRoot, mptRoot, chainConfig, chainConfig.PragueTime, mptRoot)
+			sdb.StartVerkleTransition(mptRoot, mptRoot, chainConfig, chainConfig.VerkleTime, mptRoot)
 		}
 
 		// create the state database without the snapshot, so that it's not overwritten

cmd/evm/internal/t8ntool/transition.go

@@ -314,7 +314,7 @@ func Transition(ctx *cli.Context) error {
 	// Dump the excution result
 	collector := make(Alloc)
 	var vktleaves map[common.Hash]hexutil.Bytes
-	if !chainConfig.IsPrague(big.NewInt(int64(prestate.Env.Number)), prestate.Env.Timestamp) {
+	if !chainConfig.IsVerkle(big.NewInt(int64(prestate.Env.Number)), prestate.Env.Timestamp) {
 		// Only dump accounts in MPT mode, verkle does not have the
 		// concept of an alloc.
 		s.DumpToCollector(collector, nil)

cmd/geth/chaincmd.go

@@ -49,7 +49,7 @@ var (
 		Name:      "init",
 		Usage:     "Bootstrap and initialize a new genesis block",
 		ArgsUsage: "<genesisPath>",
-		Flags:     flags.Merge([]cli.Flag{utils.CachePreimagesFlag, utils.OverridePrague}, utils.DatabasePathFlags),
+		Flags:     flags.Merge([]cli.Flag{utils.CachePreimagesFlag, utils.OverrideVerkle}, utils.DatabasePathFlags),
 		Description: `
 The init command initializes a new genesis block and definition for the network.
 This is a destructive action and changes the network in which you will be
@@ -202,9 +202,9 @@ func initGenesis(ctx *cli.Context) error {
 	defer stack.Close()
 
 	var overrides core.ChainOverrides
-	if ctx.IsSet(utils.OverridePrague.Name) {
-		v := ctx.Uint64(utils.OverridePrague.Name)
-		overrides.OverridePrague = &v
+	if ctx.IsSet(utils.OverrideVerkle.Name) {
+		v := ctx.Uint64(utils.OverrideVerkle.Name)
+		overrides.OverrideVerkle = &v
 	}
 
 	for _, name := range []string{"chaindata", "lightchaindata"} {

cmd/geth/config.go

@@ -171,9 +171,9 @@ func makeFullNode(ctx *cli.Context) (*node.Node, ethapi.Backend) {
 		v := ctx.Uint64(utils.OverrideCancun.Name)
 		cfg.Eth.OverrideCancun = &v
 	}
-	if ctx.IsSet(utils.OverridePrague.Name) {
-		v := ctx.Uint64(utils.OverridePrague.Name)
-		cfg.Eth.OverridePrague = &v
+	if ctx.IsSet(utils.OverrideVerkle.Name) {
+		v := ctx.Uint64(utils.OverrideVerkle.Name)
+		cfg.Eth.OverrideVerkle = &v
 	}
 	if ctx.IsSet(utils.OverrideProofInBlock.Name) {
 		v := ctx.Bool(utils.OverrideProofInBlock.Name)

cmd/geth/main.go

@@ -69,7 +69,7 @@ var (
 		utils.SmartCardDaemonPathFlag,
 		utils.OverrideOverlayStride,
 		utils.OverrideCancun,
-		utils.OverridePrague,
+		utils.OverrideVerkle,
 		utils.OverrideProofInBlock,
 		utils.ClearVerkleCosts,
 		utils.EnablePersonal,

cmd/utils/flags.go

@@ -274,8 +274,8 @@ var (
 		Usage:    "Manually specify the Cancun fork timestamp, overriding the bundled setting",
 		Category: flags.EthCategory,
 	}
-	OverridePrague = &cli.Uint64Flag{
-		Name:     "override.prague",
+	OverrideVerkle = &cli.Uint64Flag{
+		Name:     "override.verkle",
 		Usage:    "Manually specify the Verkle fork timestamp, overriding the bundled setting",
 		Category: flags.EthCategory,
 	}

consensus/beacon/consensus.go

@@ -361,7 +361,7 @@ func (beacon *Beacon) Finalize(chain consensus.ChainHeaderReader, header *types.
 		state.Witness().TouchFullAccount(w.Address[:], true)
 	}
 
-	if chain.Config().IsPrague(header.Number, header.Time) {
+	if chain.Config().IsVerkle(header.Number, header.Time) {
 		// uncomment when debugging
 		// fmt.Println("at block", header.Number, "performing transition?", state.Database().InTransition())
 		parent := chain.GetHeaderByHash(header.ParentHash)
@@ -403,7 +403,7 @@ func (beacon *Beacon) FinalizeAndAssemble(chain consensus.ChainHeaderReader, hea
 		keys  = state.Witness().Keys()
 		proot common.Hash
 	)
-	if chain.Config().IsPrague(header.Number, header.Time) {
+	if chain.Config().IsVerkle(header.Number, header.Time) {
 		// Open the pre-tree to prove the pre-state against
 		parent := chain.GetHeaderByNumber(header.Number.Uint64() - 1)
 		if parent == nil {
@@ -468,7 +468,7 @@ func (beacon *Beacon) FinalizeAndAssemble(chain consensus.ChainHeaderReader, hea
 
 	// Assemble and return the final block.
 	block := types.NewBlockWithWithdrawals(header, txs, uncles, receipts, withdrawals, trie.NewStackTrie(nil))
-	if chain.Config().IsPrague(header.Number, header.Time) && chain.Config().ProofInBlocks {
+	if chain.Config().IsVerkle(header.Number, header.Time) && chain.Config().ProofInBlocks {
 		block.SetVerkleProof(p, k, proot)
 	}
 	return block, nil

core/blockchain.go

@@ -320,7 +320,7 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis
 	head := bc.CurrentBlock()
 
 	// Declare the end of the verkle transition if need be
-	if bc.chainConfig.IsPrague(head.Number, head.Time) {
+	if bc.chainConfig.IsVerkle(head.Number, head.Time) {
 		// TODO this only works when resuming a chain that has already gone
 		// through the conversion. All pointers should be saved to the DB
 		// for it to be able to recover if interrupted during the transition
@@ -426,7 +426,7 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis
 			Recovery:   recover,
 			NoBuild:    bc.cacheConfig.SnapshotNoBuild,
 			AsyncBuild: !bc.cacheConfig.SnapshotWait,
-			Verkle:     chainConfig.IsPrague(head.Number, head.Time),
+			Verkle:     chainConfig.IsVerkle(head.Number, head.Time),
 		}
 		bc.snaps, _ = snapshot.New(snapconfig, bc.db, bc.triedb, head.Root)
 	}
@@ -1760,13 +1760,13 @@ func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool) (int, error)
 			parent = bc.GetHeader(block.ParentHash(), block.NumberU64()-1)
 		}
 
-		if bc.Config().IsPrague(block.Number(), block.Time()) {
+		if bc.Config().IsVerkle(block.Number(), block.Time()) {
 			bc.stateCache.LoadTransitionState(parent.Root)
 
-			// pragueTime has been reached. If the transition isn't active, it means this
+			// verkleTime has been reached. If the transition isn't active, it means this
 			// is the fork block and that the conversion needs to be marked at started.
 			if !bc.stateCache.InTransition() && !bc.stateCache.Transitioned() {
-				bc.stateCache.StartVerkleTransition(parent.Root, emptyVerkleRoot, bc.Config(), bc.Config().PragueTime, parent.Root)
+				bc.stateCache.StartVerkleTransition(parent.Root, emptyVerkleRoot, bc.Config(), bc.Config().VerkleTime, parent.Root)
 			}
 		} else {
 			// If the verkle activation time hasn't started, declare it as "not started".
@@ -2562,8 +2562,8 @@ func (bc *BlockChain) GetTrieFlushInterval() time.Duration {
 	return time.Duration(bc.flushInterval.Load())
 }
 
-func (bc *BlockChain) StartVerkleTransition(originalRoot, translatedRoot common.Hash, chainConfig *params.ChainConfig, pragueTime *uint64, root common.Hash) {
-	bc.stateCache.StartVerkleTransition(originalRoot, translatedRoot, chainConfig, pragueTime, root)
+func (bc *BlockChain) StartVerkleTransition(originalRoot, translatedRoot common.Hash, chainConfig *params.ChainConfig, verkleTime *uint64, root common.Hash) {
+	bc.stateCache.StartVerkleTransition(originalRoot, translatedRoot, chainConfig, verkleTime, root)
 }
 func (bc *BlockChain) ReorgThroughVerkleTransition() {
 	bc.stateCache.ReorgThroughVerkleTransition()

core/chain_makers.go

@@ -357,7 +357,7 @@ func GenerateChainWithGenesis(genesis *Genesis, engine consensus.Engine, n int,
 	if err != nil {
 		panic(err)
 	}
-	if genesis.Config != nil && genesis.Config.IsPrague(genesis.ToBlock().Number(), genesis.ToBlock().Time()) {
+	if genesis.Config != nil && genesis.Config.IsVerkle(genesis.ToBlock().Number(), genesis.ToBlock().Time()) {
 		blocks, receipts, _, _, _ := GenerateVerkleChain(genesis.Config, genesis.ToBlock(), engine, db, n, gen)
 		return db, blocks, receipts
 	}
@@ -386,8 +386,8 @@ func GenerateVerkleChain(config *params.ChainConfig, parent *types.Block, engine
 		preState := statedb.Copy()
 		fmt.Println("prestate", preState.GetTrie().(*trie.VerkleTrie).ToDot())
 
-		if config.IsPrague(b.header.Number, b.header.Time) {
-			if !config.IsPrague(b.parent.Number(), b.parent.Time()) {
+		if config.IsVerkle(b.header.Number, b.header.Time) {
+			if !config.IsVerkle(b.parent.Number(), b.parent.Time()) {
 				// Transition case: insert all 256 ancestors
 				InsertBlockHashHistoryAtEip2935Fork(statedb, b.header.Number.Uint64()-1, b.header.ParentHash, chainreader)
 			} else {
@@ -437,7 +437,7 @@ func GenerateVerkleChain(config *params.ChainConfig, parent *types.Block, engine
 	}
 	var snaps *snapshot.Tree
 	db := state.NewDatabaseWithConfig(diskdb, nil)
-	db.StartVerkleTransition(common.Hash{}, common.Hash{}, config, config.PragueTime, common.Hash{})
+	db.StartVerkleTransition(common.Hash{}, common.Hash{}, config, config.VerkleTime, common.Hash{})
 	db.EndVerkleTransition()
 	db.SaveTransitionState(parent.Root())
 	for i := 0; i < n; i++ {

core/genesis.go

@@ -125,7 +125,7 @@ func (ga *GenesisAlloc) deriveHash(cfg *params.ChainConfig, timestamp uint64) (c
 	// Create an ephemeral in-memory database for computing hash,
 	// all the derived states will be discarded to not pollute disk.
 	db := state.NewDatabase(rawdb.NewMemoryDatabase())
-	if cfg.IsPrague(big.NewInt(int64(0)), timestamp) {
+	if cfg.IsVerkle(big.NewInt(int64(0)), timestamp) {
 		db.StartVerkleTransition(common.Hash{}, common.Hash{}, cfg, &timestamp, common.Hash{})
 		db.EndVerkleTransition()
 	}
@@ -150,7 +150,7 @@ func (ga *GenesisAlloc) deriveHash(cfg *params.ChainConfig, timestamp uint64) (c
 func (ga *GenesisAlloc) flush(db ethdb.Database, triedb *trie.Database, blockhash common.Hash, cfg *params.ChainConfig, timestamp *uint64) error {
 	database := state.NewDatabaseWithNodeDB(db, triedb)
 	// End the verkle conversion at genesis if the fork block is 0
-	if timestamp != nil && cfg.IsPrague(big.NewInt(int64(0)), *timestamp) {
+	if timestamp != nil && cfg.IsVerkle(big.NewInt(int64(0)), *timestamp) {
 		database.StartVerkleTransition(common.Hash{}, common.Hash{}, cfg, timestamp, common.Hash{})
 		database.EndVerkleTransition()
 	}
@@ -292,7 +292,7 @@ func (e *GenesisMismatchError) Error() string {
 // ChainOverrides contains the changes to chain config.
 type ChainOverrides struct {
 	OverrideCancun        *uint64
-	OverridePrague        *uint64
+	OverrideVerkle        *uint64
 	OverrideProofInBlock  *bool
 	OverrideOverlayStride *uint64
 }
@@ -323,8 +323,8 @@ func SetupGenesisBlockWithOverride(db ethdb.Database, triedb *trie.Database, gen
 			if overrides != nil && overrides.OverrideCancun != nil {
 				config.CancunTime = overrides.OverrideCancun
 			}
-			if overrides != nil && overrides.OverridePrague != nil {
-				config.PragueTime = overrides.OverridePrague
+			if overrides != nil && overrides.OverrideVerkle != nil {
+				config.VerkleTime = overrides.OverrideVerkle
 			}
 		}
 	}
@@ -375,7 +375,7 @@ func SetupGenesisBlockWithOverride(db ethdb.Database, triedb *trie.Database, gen
 	newcfg := genesis.configOrDefault(stored)
 	applyOverrides(newcfg)
 	// WORKAROUND it looks like this is broken, because overriding
-	// pragueTime will cause an error here, claiming that shanghaiTime
+	// verkleTime will cause an error here, claiming that shanghaiTime
 	// wasn't set (it is).
 	// if err := newcfg.CheckConfigForkOrder(); err != nil {
 	// 	return newcfg, common.Hash{}, err
@@ -464,7 +464,7 @@ func (g *Genesis) configOrDefault(ghash common.Hash) *params.ChainConfig {
 // IsVerkle indicates whether the state is already stored in a verkle
 // tree at genesis time.
 func (g *Genesis) IsVerkle() bool {
-	return g.Config.IsPrague(new(big.Int).SetUint64(g.Number), g.Timestamp)
+	return g.Config.IsVerkle(new(big.Int).SetUint64(g.Number), g.Timestamp)
 }
 
 // ToBlock returns the genesis block according to genesis specification.
@@ -560,7 +560,7 @@ func (g *Genesis) Commit(db ethdb.Database, triedb *trie.Database) (*types.Block
 // Note the state changes will be committed in hash-based scheme, use Commit
 // if path-scheme is preferred.
 func (g *Genesis) MustCommit(db ethdb.Database) *types.Block {
-	triedb := trie.NewDatabaseWithConfig(db, &trie.Config{Verkle: g.Config != nil && g.Config.IsPrague(big.NewInt(int64(g.Number)), g.Timestamp)})
+	triedb := trie.NewDatabaseWithConfig(db, &trie.Config{Verkle: g.Config != nil && g.Config.IsVerkle(big.NewInt(int64(g.Number)), g.Timestamp)})
 	block, err := g.Commit(db, triedb)
 	if err != nil {
 		panic(err)

core/state/database.go

@@ -74,7 +74,7 @@ type Database interface {
 	// TrieDB retrieves the low level trie database used for data storage.
 	TrieDB() *trie.Database
 
-	StartVerkleTransition(originalRoot, translatedRoot common.Hash, chainConfig *params.ChainConfig, pragueTime *uint64, root common.Hash)
+	StartVerkleTransition(originalRoot, translatedRoot common.Hash, chainConfig *params.ChainConfig, verkleTime *uint64, root common.Hash)
 
 	ReorgThroughVerkleTransition()
 
@@ -232,7 +232,7 @@ func (db *cachingDB) Transitioned() bool {
 }
 
 // Fork implements the fork
-func (db *cachingDB) StartVerkleTransition(originalRoot, translatedRoot common.Hash, chainConfig *params.ChainConfig, pragueTime *uint64, root common.Hash) {
+func (db *cachingDB) StartVerkleTransition(originalRoot, translatedRoot common.Hash, chainConfig *params.ChainConfig, verkleTime *uint64, root common.Hash) {
 	if useBanner {
 		fmt.Println(`
 	__________.__                       .__                .__                   __       .__                               .__          ____         
@@ -251,8 +251,8 @@ func (db *cachingDB) StartVerkleTransition(originalRoot, translatedRoot common.H
 	db.baseRoot = originalRoot
 
 	// Reinitialize values in case of a reorg
-	if pragueTime != nil {
-		chainConfig.PragueTime = pragueTime
+	if verkleTime != nil {
+		chainConfig.VerkleTime = verkleTime
 	}
 }
 

core/state_processor.go

@@ -78,7 +78,7 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 		vmenv   = vm.NewEVM(context, vm.TxContext{}, statedb, p.config, cfg)
 		signer  = types.MakeSigner(p.config, header.Number, header.Time)
 	)
-	if p.config.IsPrague(block.Number(), block.Time()) {
+	if p.config.IsVerkle(block.Number(), block.Time()) {
 		ProcessParentBlockHash(statedb, block.NumberU64()-1, block.ParentHash())
 	}
 	// Iterate over and process the individual transactions