update for test

.nancy-ignore

@@ -1,2 +1 @@
 CVE-2024-34478 # "CWE-754: Improper Check for Unusual or Exceptional Conditions." This vulnerability is BTC only, BSC does not have the issue.
-CVE-2024-6104 # "CWE-532: Information Exposure Through Log Files" This is caused by the vulnerabilities go-retryablehttp@v0.7.4, it is only used in cmd devp2p, impact is limited. will upgrade to v0.7.7 later

CHANGELOG.md

@@ -1,41 +1,4 @@
 # Changelog
-
-## v1.4.12
-
-### BUGFIX
-* [\#2557](https://github.com/bnb-chain/bsc/pull/2557) fix: fix state inspect error after pruned state
-* [\#2562](https://github.com/bnb-chain/bsc/pull/2562) fix: delete unexpected block
-* [\#2566](https://github.com/bnb-chain/bsc/pull/2566) core: avoid to cache block before wroten into db
-* [\#2567](https://github.com/bnb-chain/bsc/pull/2567) fix: fix statedb copy
-* [\#2574](https://github.com/bnb-chain/bsc/pull/2574) core: adapt highestVerifiedHeader to FastFinality
-* [\#2542](https://github.com/bnb-chain/bsc/pull/2542) fix: pruneancient freeze from the previous position when the first time
-* [\#2564](https://github.com/bnb-chain/bsc/pull/2564) fix: the bug of blobsidecars and downloader with multi-database
-* [\#2582](https://github.com/bnb-chain/bsc/pull/2582) fix: remove delete and dangling side chains in prunefreezer
-
-### FEATURE
-* [\#2513](https://github.com/bnb-chain/bsc/pull/2513) cmd/jsutils: add a tool to get performance between a range of blocks
-* [\#2569](https://github.com/bnb-chain/bsc/pull/2569) cmd/jsutils: add a tool to get slash count
-* [\#2583](https://github.com/bnb-chain/bsc/pull/2583) cmd/jsutill: add log about validator name
-
-### IMPROVEMENT
-* [\#2546](https://github.com/bnb-chain/bsc/pull/2546) go.mod: update missing dependency
-* [\#2559](https://github.com/bnb-chain/bsc/pull/2559) nancy: ignore go-retryablehttp@v0.7.4 in .nancy-ignore
-* [\#2556](https://github.com/bnb-chain/bsc/pull/2556) chore: update greenfield cometbft version
-* [\#2561](https://github.com/bnb-chain/bsc/pull/2561) tests: fix unstable test
-* [\#2572](https://github.com/bnb-chain/bsc/pull/2572) core: clearup testflag for Cancun and Haber
-* [\#2573](https://github.com/bnb-chain/bsc/pull/2573) cmd/utils: support use NetworkId to distinguish chapel when do syncing
-* [\#2538](https://github.com/bnb-chain/bsc/pull/2538) feat: enhance bid comparison and reply bidding results && detail logs
-* [\#2568](https://github.com/bnb-chain/bsc/pull/2568) core/vote: not vote if too late for next in turn validator
-* [\#2576](https://github.com/bnb-chain/bsc/pull/2576) miner/worker: broadcast block immediately once sealed
-* [\#2580](https://github.com/bnb-chain/bsc/pull/2580) freezer: Opt freezer env checking
-
-## v1.4.11
-
-### BUGFIX
-* [\#2534](https://github.com/bnb-chain/bsc/pull/2534) fix: nil pointer when clear simulating bid
-* [\#2535](https://github.com/bnb-chain/bsc/pull/2535) upgrade: add HaberFix hardfork
-
-
 ## v1.4.10
 ### FEATURE
 NA

README.md

@@ -149,6 +149,8 @@ unzip testnet.zip
 #### 3. Download snapshot
 Download latest chaindata snapshot from [here](https://github.com/bnb-chain/bsc-snapshots). Follow the guide to structure your files.
 
+Note: If you encounter difficulties downloading the chaindata snapshot and prefer to synchronize from the genesis block on the Chapel testnet, remember to include the additional flag `--chapel` when initially launching Geth.
+
 #### 4. Start a full node
 ```shell
 ./geth --config ./config.toml --datadir ./node  --cache 8000 --rpc.allow-unprotected-txs --history.transactions 0

cmd/evm/internal/t8ntool/execution.go

@@ -349,7 +349,6 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 	}
 	// Re-create statedb instance with new root upon the updated database
 	// for accessing latest states.
-	// TODO:: state.NewDatabase internally compatible with versa is sufficient.
 	statedb, err = state.New(root, statedb.Database(), nil)
 	if err != nil {
 		return nil, nil, nil, NewError(ErrorEVM, fmt.Errorf("could not reopen state: %v", err))
@@ -359,9 +358,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 }
 
 func MakePreState(db ethdb.Database, accounts types.GenesisAlloc) *state.StateDB {
-	// TODO:: state.NewDatabase internally compatible with versa is sufficient.
 	sdb := state.NewDatabaseWithConfig(db, &triedb.Config{Preimages: true})
-	// TODO:: state.NewDatabase internally compatible with versa is sufficient.
 	statedb, _ := state.New(types.EmptyRootHash, sdb, nil)
 	for addr, a := range accounts {
 		statedb.SetCode(addr, a.Code)
@@ -375,7 +372,6 @@ func MakePreState(db ethdb.Database, accounts types.GenesisAlloc) *state.StateDB
 	statedb.Finalise(false)
 	statedb.AccountsIntermediateRoot()
 	root, _, _ := statedb.Commit(0, nil)
-	// TODO:: state.NewDatabase internally compatible with versa is sufficient.
 	statedb, _ = state.New(root, sdb, nil)
 	return statedb
 }

cmd/evm/runner.go

@@ -148,14 +148,12 @@ func runCmd(ctx *cli.Context) error {
 	}
 
 	db := rawdb.NewMemoryDatabase()
-	// TODO:: ignore cmd, if use versa if should be nil, if triedb is not used later in this func
 	triedb := triedb.NewDatabase(db, &triedb.Config{
 		Preimages: preimages,
 		HashDB:    hashdb.Defaults,
 	})
 	defer triedb.Close()
 	genesis := genesisConfig.MustCommit(db, triedb)
-	// TODO:: ignore cmd, internally compatible with versa is sufficient.
 	sdb := state.NewDatabaseWithNodeDB(db, triedb)
 	statedb, _ = state.New(genesis.Root(), sdb, nil)
 	chainConfig = genesisConfig.Config

cmd/evm/staterunner.go

@@ -109,7 +109,6 @@ func runStateTest(fname string, cfg vm.Config, jsonOut, dump bool) error {
 						fmt.Fprintf(os.Stderr, "{\"stateRoot\": \"%#x\"}\n", root)
 					}
 					if dump { // Dump any state to aid debugging
-						// TODO:: state.NewDatabase internally compatible with versa is sufficient.
 						cpy, _ := state.New(root, tstate.StateDB.Database(), nil)
 						dump := cpy.RawDump(nil)
 						result.State = &dump

cmd/faucet/faucet.go

@@ -642,7 +642,7 @@ func (f *faucet) loop() {
 			f.lock.RUnlock()
 		}
 	}()
-	// Wait for various events and assign to the appropriate background threads
+	// Wait for various events and assing to the appropriate background threads
 	for {
 		select {
 		case head := <-heads:

cmd/geth/chaincmd.go

@@ -62,9 +62,10 @@ var (
 		ArgsUsage: "<genesisPath>",
 		Flags: flags.Merge([]cli.Flag{
 			utils.CachePreimagesFlag,
+			utils.OverrideCancun,
+			utils.OverrideHaber,
 			utils.OverrideBohr,
 			utils.OverrideVerkle,
-			utils.MultiDataBaseFlag,
 		}, utils.DatabaseFlags),
 		Description: `
 The init command initializes a new genesis block and definition for the network.
@@ -253,6 +254,14 @@ func initGenesis(ctx *cli.Context) error {
 	defer stack.Close()
 
 	var overrides core.ChainOverrides
+	if ctx.IsSet(utils.OverrideCancun.Name) {
+		v := ctx.Uint64(utils.OverrideCancun.Name)
+		overrides.OverrideCancun = &v
+	}
+	if ctx.IsSet(utils.OverrideHaber.Name) {
+		v := ctx.Uint64(utils.OverrideHaber.Name)
+		overrides.OverrideHaber = &v
+	}
 	if ctx.IsSet(utils.OverrideBohr.Name) {
 		v := ctx.Uint64(utils.OverrideBohr.Name)
 		overrides.OverrideBohr = &v
@@ -760,7 +769,7 @@ func parseDumpConfig(ctx *cli.Context, stack *node.Node) (*state.DumpConfig, eth
 		arg := ctx.Args().First()
 		if hashish(arg) {
 			hash := common.HexToHash(arg)
-			if number := rawdb.ReadHeaderNumber(db, hash); number != nil {
+			if number := rawdb.ReadHeaderNumber(db.BlockStore(), hash); number != nil {
 				header = rawdb.ReadHeader(db, hash, *number)
 			} else {
 				return nil, nil, common.Hash{}, fmt.Errorf("block %x not found", hash)
@@ -778,7 +787,6 @@ func parseDumpConfig(ctx *cli.Context, stack *node.Node) (*state.DumpConfig, eth
 		}
 	} else {
 		// Use latest
-		// TODO:: if versa, scheme = VersaScheme
 		if scheme == rawdb.PathScheme {
 			triedb := triedb.NewDatabase(db, &triedb.Config{PathDB: utils.PathDBConfigAddJournalFilePath(stack, pathdb.ReadOnly)})
 			defer triedb.Close()
@@ -834,7 +842,6 @@ func dump(ctx *cli.Context) error {
 	triedb := utils.MakeTrieDatabase(ctx, stack, db, true, true, false) // always enable preimage lookup
 	defer triedb.Close()
 
-	// TODO:: state.NewDatabase internally compatible with versa is sufficient.
 	state, err := state.New(root, state.NewDatabaseWithNodeDB(db, triedb), nil)
 	if err != nil {
 		return err
@@ -852,7 +859,6 @@ func dumpAllRootHashInPath(ctx *cli.Context) error {
 	defer stack.Close()
 	db := utils.MakeChainDatabase(ctx, stack, true, false)
 	defer db.Close()
-	// TODO:: ignore cmd
 	triedb := triedb.NewDatabase(db, &triedb.Config{PathDB: utils.PathDBConfigAddJournalFilePath(stack, pathdb.ReadOnly)})
 	defer triedb.Close()
 

cmd/geth/config.go

@@ -185,6 +185,14 @@ func makeFullNode(ctx *cli.Context) (*node.Node, ethapi.Backend) {
 		params.RialtoGenesisHash = common.HexToHash(v)
 	}
 
+	if ctx.IsSet(utils.OverrideCancun.Name) {
+		v := ctx.Uint64(utils.OverrideCancun.Name)
+		cfg.Eth.OverrideCancun = &v
+	}
+	if ctx.IsSet(utils.OverrideHaber.Name) {
+		v := ctx.Uint64(utils.OverrideHaber.Name)
+		cfg.Eth.OverrideHaber = &v
+	}
 	if ctx.IsSet(utils.OverrideBohr.Name) {
 		v := ctx.Uint64(utils.OverrideBohr.Name)
 		cfg.Eth.OverrideBohr = &v

cmd/geth/dbcmd.go

@@ -397,8 +397,8 @@ func inspectTrie(ctx *cli.Context) error {
 	var headerBlockHash common.Hash
 	if ctx.NArg() >= 1 {
 		if ctx.Args().Get(0) == "latest" {
-			headerHash := rawdb.ReadHeadHeaderHash(db)
-			blockNumber = *(rawdb.ReadHeaderNumber(db, headerHash))
+			headerHash := rawdb.ReadHeadHeaderHash(db.BlockStore())
+			blockNumber = *(rawdb.ReadHeaderNumber(db.BlockStore(), headerHash))
 		} else if ctx.Args().Get(0) == "snapshot" {
 			trieRootHash = rawdb.ReadSnapshotRoot(db)
 			blockNumber = math.MaxUint64
@@ -457,7 +457,6 @@ func inspectTrie(ctx *cli.Context) error {
 			config = triedb.HashDefaults
 		}
 
-		// TODO:: ignore cmd
 		triedb := triedb.NewDatabase(db, config)
 		theTrie, err := trie.New(trie.TrieID(trieRootHash), triedb)
 		if err != nil {
@@ -1213,7 +1212,7 @@ func showMetaData(ctx *cli.Context) error {
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error accessing ancients: %v", err)
 	}
-	data := rawdb.ReadChainMetadata(db)
+	data := rawdb.ReadChainMetadataFromMultiDatabase(db)
 	data = append(data, []string{"frozen", fmt.Sprintf("%d items", ancients)})
 	data = append(data, []string{"snapshotGenerator", snapshot.ParseGeneratorStatus(rawdb.ReadSnapshotGenerator(db))})
 	if b := rawdb.ReadHeadBlock(db); b != nil {
@@ -1256,7 +1255,7 @@ func hbss2pbss(ctx *cli.Context) error {
 	defer stack.Close()
 
 	db := utils.MakeChainDatabase(ctx, stack, false, false)
-	db.BlockStore().Sync()
+	db.Sync()
 	stateDiskDb := db.StateStore()
 	defer db.Close()
 
@@ -1269,14 +1268,13 @@ func hbss2pbss(ctx *cli.Context) error {
 	}
 	if lastStateID == 0 || force {
 		config := triedb.HashDefaults
-		// TODO:: ignore cmd
 		triedb := triedb.NewDatabase(db, config)
 		triedb.Cap(0)
 		log.Info("hbss2pbss triedb", "scheme", triedb.Scheme())
 		defer triedb.Close()
 
-		headerHash := rawdb.ReadHeadHeaderHash(db)
-		blockNumber := rawdb.ReadHeaderNumber(db, headerHash)
+		headerHash := rawdb.ReadHeadHeaderHash(db.BlockStore())
+		blockNumber := rawdb.ReadHeaderNumber(db.BlockStore(), headerHash)
 		if blockNumber == nil {
 			log.Error("read header number failed.")
 			return fmt.Errorf("read header number failed")

cmd/geth/main.go

@@ -72,6 +72,8 @@ var (
 		utils.USBFlag,
 		utils.SmartCardDaemonPathFlag,
 		utils.RialtoHash,
+		utils.OverrideCancun,
+		utils.OverrideHaber,
 		utils.OverrideBohr,
 		utils.OverrideVerkle,
 		utils.OverrideFullImmutabilityThreshold,
@@ -125,7 +127,6 @@ var (
 		utils.CacheSnapshotFlag,
 		// utils.CacheNoPrefetchFlag,
 		utils.CachePreimagesFlag,
-		utils.MultiDataBaseFlag,
 		utils.PersistDiffFlag,
 		utils.DiffBlockFlag,
 		utils.PruneAncientDataFlag,
@@ -335,6 +336,9 @@ func prepare(ctx *cli.Context) {
   5. Networking is disabled; there is no listen-address, the maximum number of peers is set
      to 0, and discovery is disabled.
 `)
+
+	case !ctx.IsSet(utils.NetworkIdFlag.Name):
+		log.Info("Starting Geth on BSC mainnet...")
 	}
 	// If we're a full node on mainnet without --cache specified, bump default cache allowance
 	if !ctx.IsSet(utils.CacheFlag.Name) && !ctx.IsSet(utils.NetworkIdFlag.Name) {

cmd/geth/pruneblock_test.go

@@ -155,12 +155,6 @@ func BlockchainCreator(t *testing.T, chaindbPath, AncientPath string, blockRemai
 	triedb := triedb.NewDatabase(db, nil)
 	defer triedb.Close()
 
-	if err = db.SetupFreezerEnv(&ethdb.FreezerEnv{
-		ChainCfg:         gspec.Config,
-		BlobExtraReserve: params.DefaultExtraReserveForBlobRequests,
-	}); err != nil {
-		t.Fatalf("Failed to create chain: %v", err)
-	}
 	genesis := gspec.MustCommit(db, triedb)
 	// Initialize a fresh chain with only a genesis block
 	blockchain, err := core.NewBlockChain(db, config, gspec, nil, engine, vm.Config{}, nil, nil)

cmd/geth/snapshot.go

@@ -256,7 +256,6 @@ func accessDb(ctx *cli.Context, stack *node.Node) (ethdb.Database, error) {
 	} else if dbScheme == rawdb.HashScheme {
 		config = triedb.HashDefaults
 	}
-	// TODO:: ignore snapshot
 	snaptree, err := snapshot.New(snapconfig, chaindb, triedb.NewDatabase(chaindb, config), headBlock.Root(), TriesInMemory, false)
 	if err != nil {
 		log.Error("snaptree error", "err", err)

cmd/jsutils/README.md

@@ -25,23 +25,3 @@ testnet validators version
 ```bash
 node gettxcount.js --rpc ${url} --startNum ${start} --endNum ${end} --miner ${miner} (optional)
 ```
-
-### 3. Get Performance
-```bash
-node get_perf.js --rpc ${url} --startNum ${start} --endNum ${end}
-```
-output as following
-```bash
-Get the performance between [ 19470 , 19670 )
-txCountPerBlock = 3142.81 txCountTotal = 628562 BlockCount = 200 avgBlockTime = 3.005 inturnBlocksRatio = 0.975
-txCountPerSecond = 1045.8602329450914 avgGasUsedPerBlock = 250.02062627 avgGasUsedPerSecond =  83.20153952412646
-```
-
-### 4. Get validators slash count
-```bash
-use the latest block 
-node getslashcount.js --Rpc ${ArchiveRpc} 
-use a block number
-node getslashcount.js --Rpc ${ArchiveRpc} --Num ${blockNum}
-```
-

cmd/jsutils/get_perf.js

@@ -1,58 +0,0 @@
-import { ethers } from "ethers";
-import program from "commander";
-
-program.option("--rpc <rpc>", "Rpc");
-program.option("--startNum <startNum>", "start num")
-program.option("--endNum <endNum>", "end num")
-program.parse(process.argv);
-
-const provider = new ethers.JsonRpcProvider(program.rpc)
-
-const main = async () => {
-    let txCountTotal = 0;
-    let gasUsedTotal = 0;
-    let inturnBlocks = 0;
-    for (let i = program.startNum; i < program.endNum; i++) {
-        let txCount = await provider.send("eth_getBlockTransactionCountByNumber", [
-            ethers.toQuantity(i)]);
-        txCountTotal += ethers.toNumber(txCount)
-
-        let header = await provider.send("eth_getHeaderByNumber", [
-            ethers.toQuantity(i)]);
-        let gasUsed = eval(eval(header.gasUsed).toString(10))
-        gasUsedTotal += gasUsed
-        let difficulty = eval(eval(header.difficulty).toString(10))
-        if (difficulty == 2) {
-            inturnBlocks += 1
-        }
-        let timestamp = eval(eval(header.timestamp).toString(10))
-        console.log("BlockNumber =", i, "mod =", i%4, "miner =", header.miner , "difficulty =", difficulty, "txCount =", ethers.toNumber(txCount), "gasUsed", gasUsed, "timestamp", timestamp)
-    }
-
-    let blockCount = program.endNum - program.startNum
-    let txCountPerBlock = txCountTotal/blockCount
-
-    let startHeader = await provider.send("eth_getHeaderByNumber", [
-        ethers.toQuantity(program.startNum)]);
-    let startTime = eval(eval(startHeader.timestamp).toString(10))
-    let endHeader = await provider.send("eth_getHeaderByNumber", [
-        ethers.toQuantity(program.endNum)]);
-    let endTime = eval(eval(endHeader.timestamp).toString(10))
-    let timeCost = endTime - startTime
-    let avgBlockTime = timeCost/blockCount
-    let inturnBlocksRatio = inturnBlocks/blockCount
-    let tps = txCountTotal/timeCost
-    let M = 1000000
-    let avgGasUsedPerBlock = gasUsedTotal/blockCount/M
-    let avgGasUsedPerSecond = gasUsedTotal/timeCost/M
-
-    console.log("Get the performance between [", program.startNum, ",", program.endNum, ")");
-    console.log("txCountPerBlock =", txCountPerBlock, "txCountTotal =", txCountTotal, "BlockCount =", blockCount, "avgBlockTime =", avgBlockTime, "inturnBlocksRatio =", inturnBlocksRatio);
-    console.log("txCountPerSecond =", tps, "avgGasUsedPerBlock =", avgGasUsedPerBlock, "avgGasUsedPerSecond =", avgGasUsedPerSecond);
-};
-
-main().then(() => process.exit(0))
-    .catch((error) => {
-        console.error(error);
-        process.exit(1);
-    });

cmd/jsutils/getslashcount.js

@@ -1,119 +0,0 @@
-import { ethers } from "ethers";
-import program from "commander";
-
-program.option("--Rpc <Rpc>", "Rpc");
-program.option("--Num <Num>", "num", 0)
-program.parse(process.argv);
-
-const provider = new ethers.JsonRpcProvider(program.Rpc);
-
-const slashAbi = [
-    "function getSlashIndicator(address validatorAddr) external view returns (uint256, uint256)"
-]
-const validatorSetAbi = [
-    "function getLivingValidators() external view returns (address[], bytes[])"
-]
-const stakeHubAbi = [
-    "function getValidatorDescription(address validatorAddr) external view returns (tuple(string, string, string, string))",
-    "function consensusToOperator(address consensusAddr) public view returns (address)"
-]
-const addrValidatorSet = '0x0000000000000000000000000000000000001000';
-const validatorSet = new ethers.Contract(addrValidatorSet, validatorSetAbi, provider);
-
-const addrSlash = '0x0000000000000000000000000000000000001001';
-const slashIndicator = new ethers.Contract(addrSlash, slashAbi,  provider)
-
-const addrStakeHub = '0x0000000000000000000000000000000000002002';
-const stakeHub = new ethers.Contract(addrStakeHub, stakeHubAbi, provider)
-
-const validatorMap = new Map([
-    //BSC
-    ["0x37e9627A91DD13e453246856D58797Ad6583D762", "LegendII"],
-    ["0xB4647b856CB9C3856d559C885Bed8B43e0846a47", "CertiK"],
-    ["0x75B851a27D7101438F45fce31816501193239A83", "Figment"],
-    ["0x502aECFE253E6AA0e8D2A06E12438FFeD0Fe16a0", "BscScan"],
-    ["0xCa503a7eD99eca485da2E875aedf7758472c378C", "InfStones"],
-    ["0x5009317FD4F6F8FeEa9dAe41E5F0a4737BB7A7D5", "NodeReal"],
-    ["0x1cFDBd2dFf70C6e2e30df5012726F87731F38164", "Tranchess"],
-    ["0xF8de5e61322302b2c6e0a525cC842F10332811bf", "Namelix"],
-    ["0xCcB42A9b8d6C46468900527Bc741938E78AB4577", "Turing"],
-    ["0x9f1b7FAE54BE07F4FEE34Eb1aaCb39A1F7B6FC92", "TWStaking"],
-    ["0x7E1FdF03Eb3aC35BF0256694D7fBe6B6d7b3E0c8","LegendIII"],
-    ["0x7b501c7944185130DD4aD73293e8Aa84eFfDcee7","MathW"],
-    ["0x58567F7A51a58708C8B40ec592A38bA64C0697De","Legend"],
-    ["0x460A252B4fEEFA821d3351731220627D7B7d1F3d","Defibit"],
-    ["0x8A239732871AdC8829EA2f47e94087C5FBad47b6","The48Club"],
-    ["0xD3b0d838cCCEAe7ebF1781D11D1bB741DB7Fe1A7","BNBEve"],
-    ["0xF8B99643fAfC79d9404DE68E48C4D49a3936f787","Avengers"],
-    ["0x4e5acf9684652BEa56F2f01b7101a225Ee33d23f","HashKey"],
-    ["0x9bb56C2B4DBE5a06d79911C9899B6f817696ACFc","Feynman"],
-    ["0xbdcc079BBb23C1D9a6F36AA31309676C258aBAC7","Fuji"],
-    ["0x38944092685a336CB6B9ea58836436709a2adC89","Shannon"],
-    ["0xfC1004C0f296Ec3Df4F6762E9EabfcF20EB304a2","Aoraki"],
-    ["0xa0884bb00E5F23fE2427f0E5eC9E51F812848563","Coda"],
-    ["0xe7776De78740f28a96412eE5cbbB8f90896b11A5","Ankr"],
-    ["0xA2D969E82524001Cb6a2357dBF5922B04aD2FCD8","Pexmons"],
-    ["0x5cf810AB8C718ac065b45f892A5BAdAB2B2946B9","Zen"],
-    ["0x4d15D9BCd0c2f33E7510c0de8b42697CA558234a","LegendVII"],
-    ["0x1579ca96EBd49A0B173f86C372436ab1AD393380","LegendV"],
-    ["0xd1F72d433f362922f6565FC77c25e095B29141c8","LegendVI"],
-    ["0xf9814D93b4d904AaA855cBD4266D6Eb0Ec1Aa478","Legend8"],
-    ["0x025a4e09Ea947b8d695f53ddFDD48ddB8F9B06b7","Ciscox"],
-    ["0xE9436F6F30b4B01b57F2780B2898f3820EbD7B98","LegendIV"],
-    ["0xC2d534F079444E6E7Ff9DabB3FD8a26c607932c8","Axion"],
-    ["0x9F7110Ba7EdFda83Fc71BeA6BA3c0591117b440D","LegendIX"],
-    ["0xB997Bf1E3b96919fBA592c1F61CE507E165Ec030","Seoraksan"],
-    ["0x286C1b674d48cFF67b4096b6c1dc22e769581E91","Sigm8"],
-    ["0x73A26778ef9509a6E94b55310eE7233795a9EB25","Coinlix"],
-    ["0x18c44f4FBEde9826C7f257d500A65a3D5A8edebc","Nozti"],
-    ["0xA100FCd08cE722Dc68Ddc3b54237070Cb186f118","Tiollo"],
-    ["0x0F28847cfdbf7508B13Ebb9cEb94B2f1B32E9503","Raptas"],
-    ["0xfD85346c8C991baC16b9c9157e6bdfDACE1cD7d7","Glorin"],
-    ["0x978F05CED39A4EaFa6E8FD045Fe2dd6Da836c7DF","NovaX"],
-    ["0xd849d1dF66bFF1c2739B4399425755C2E0fAbbAb","Nexa"],
-    ["0xA015d9e9206859c13201BB3D6B324d6634276534","Star"],
-    ["0x5ADde0151BfAB27f329e5112c1AeDeed7f0D3692","Veri"],
-    //Chapel
-    ["0x08265dA01E1A65d62b903c7B34c08cB389bF3D99","Ararat"],
-    ["0x7f5f2cF1aec83bF0c74DF566a41aa7ed65EA84Ea","Kita"],
-    ["0x53387F3321FD69d1E030BB921230dFb188826AFF","Fuji"],
-    ["0x76D76ee8823dE52A1A431884c2ca930C5e72bff3","Seoraksan"],
-    ["0xd447b49CD040D20BC21e49ffEa6487F5638e4346","Everest"],
-    ["0x1a3d9D7A717D64e6088aC937d5aAcDD3E20ca963","Elbrus"],
-    ["0x40D3256EB0BaBE89f0ea54EDAa398513136612f5","Bloxroute"],
-    ["0xF9a1Db0d6f22Bd78ffAECCbc8F47c83Df9FBdbCf","Test"]
-]);
-
-
-const main = async () => {
-    let blockNum = ethers.getNumber(program.Num)
-    if (blockNum === 0) {
-       blockNum = await provider.getBlockNumber()
-    }
-    let block = await provider.getBlock(blockNum)
-    console.log("At block", blockNum, "time", block.date)
-    const data = await validatorSet.getLivingValidators({blockTag:blockNum})
-    let totalSlash = 0
-    for (let i = 0; i < data[0].length; i++) {
-        let addr = data[0][i];
-        var val
-        if (!validatorMap.has(addr)) {
-            let opAddr = await stakeHub.consensusToOperator(addr, {blockTag:blockNum})
-            let value = await stakeHub.getValidatorDescription(opAddr, {blockTag:blockNum})
-            val = value[0]
-            console.log(addr, val)
-        } else {
-            val = validatorMap.get(addr)
-        }
-        let info = await slashIndicator.getSlashIndicator(addr, {blockTag:blockNum})
-        let count = ethers.toNumber(info[1])
-        totalSlash += count
-        console.log("Slash:", count, addr, val)
-    }
-    console.log("Total slash count", totalSlash)
-};
-main().then(() => process.exit(0))
-    .catch((error) => {
-        console.error(error);
-        process.exit(1);
-    });

cmd/utils/flags.go

@@ -305,6 +305,16 @@ var (
 		Usage:    "Manually specify the Rialto Genesis Hash, to trigger builtin network logic",
 		Category: flags.EthCategory,
 	}
+	OverrideCancun = &cli.Uint64Flag{
+		Name:     "override.cancun",
+		Usage:    "Manually specify the Cancun fork timestamp, overriding the bundled setting",
+		Category: flags.EthCategory,
+	}
+	OverrideHaber = &cli.Uint64Flag{
+		Name:     "override.haber",
+		Usage:    "Manually specify the Haber fork timestamp, overriding the bundled setting",
+		Category: flags.EthCategory,
+	}
 	OverrideBohr = &cli.Uint64Flag{
 		Name:     "override.bohr",
 		Usage:    "Manually specify the Bohr fork timestamp, overriding the bundled setting",
@@ -1153,6 +1163,7 @@ var (
 		DBEngineFlag,
 		StateSchemeFlag,
 		HttpHeaderFlag,
+		MultiDataBaseFlag,
 	}
 )
 
@@ -2072,7 +2083,7 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) {
 		}
 		cfg.Genesis = core.DefaultBSCGenesisBlock()
 		SetDNSDiscoveryDefaults(cfg, params.BSCGenesisHash)
-	case ctx.Bool(ChapelFlag.Name) || cfg.NetworkId == 97:
+	case ctx.Bool(ChapelFlag.Name):
 		if !ctx.IsSet(NetworkIdFlag.Name) {
 			cfg.NetworkId = 97
 		}
@@ -2589,7 +2600,6 @@ func MakeTrieDatabase(ctx *cli.Context, stack *node.Node, disk ethdb.Database, p
 		// ignore the parameter silently. TODO(rjl493456442)
 		// please config it if read mode is implemented.
 		config.HashDB = hashdb.Defaults
-		// TODO::skip MakeTrieDatabase
 		return triedb.NewDatabase(disk, config)
 	}
 	if readOnly {
@@ -2598,7 +2608,6 @@ func MakeTrieDatabase(ctx *cli.Context, stack *node.Node, disk ethdb.Database, p
 		config.PathDB = pathdb.Defaults
 	}
 	config.PathDB.JournalFilePath = fmt.Sprintf("%s/%s", stack.ResolvePath("chaindata"), eth.JournalFileName)
-	// TODO::skip MakeTrieDatabase
 	return triedb.NewDatabase(disk, config)
 }
 

cmd/utils/history_test.go

@@ -83,7 +83,7 @@ func TestHistoryImportAndExport(t *testing.T) {
 		t.Fatalf("unable to initialize chain: %v", err)
 	}
 	if _, err := chain.InsertChain(blocks); err != nil {
-		t.Fatalf("error inserting chain: %v", err)
+		t.Fatalf("error insterting chain: %v", err)
 	}
 
 	// Make temp directory for era files.

consensus/parlia/parlia.go

@@ -307,10 +307,6 @@ func New(
 	return c
 }
 
-func (p *Parlia) Period() uint64 {
-	return p.config.Period
-}
-
 func (p *Parlia) IsSystemTransaction(tx *types.Transaction, header *types.Header) (bool, error) {
 	// deploy a contract
 	if tx.To() == nil {

core/blockchain.go

@@ -336,7 +336,6 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis
 	diffLayerChanCache, _ := exlru.New(diffLayerCacheLimit)
 
 	// Open trie database with provided config
-	// TODO:: if versa , have its owen init genesis logic
 	triedb := triedb.NewDatabase(db, cacheConfig.triedbConfig())
 
 	// Setup the genesis block, commit the provided genesis specification
@@ -385,7 +384,6 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis
 	}
 	bc.flushInterval.Store(int64(cacheConfig.TrieTimeLimit))
 	bc.forker = NewForkChoice(bc, shouldPreserve)
-	// TODO:: state.NewDatabase internally compatible with versa is sufficient.
 	bc.stateCache = state.NewDatabaseWithNodeDB(bc.db, bc.triedb)
 	bc.validator = NewBlockValidator(chainConfig, bc, engine)
 	bc.prefetcher = NewStatePrefetcher(chainConfig, bc, engine)
@@ -464,8 +462,8 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis
 		}
 	}
 	// Ensure that a previous crash in SetHead doesn't leave extra ancients
-	if frozen, err := bc.db.BlockStore().ItemAmountInAncient(); err == nil && frozen > 0 {
-		frozen, err = bc.db.BlockStore().Ancients()
+	if frozen, err := bc.db.ItemAmountInAncient(); err == nil && frozen > 0 {
+		frozen, err = bc.db.Ancients()
 		if err != nil {
 			return nil, err
 		}
@@ -659,13 +657,20 @@ func (bc *BlockChain) cacheDiffLayer(diffLayer *types.DiffLayer, diffLayerCh cha
 	}
 }
 
+func (bc *BlockChain) cacheBlock(hash common.Hash, block *types.Block) {
+	bc.blockCache.Add(hash, block)
+	if bc.chainConfig.IsCancun(block.Number(), block.Time()) {
+		bc.sidecarsCache.Add(hash, block.Sidecars())
+	}
+}
+
 // empty returns an indicator whether the blockchain is empty.
 // Note, it's a special case that we connect a non-empty ancient
 // database with an empty node, so that we can plugin the ancient
 // into node seamlessly.
 func (bc *BlockChain) empty() bool {
 	genesis := bc.genesisBlock.Hash()
-	for _, hash := range []common.Hash{rawdb.ReadHeadBlockHash(bc.db), rawdb.ReadHeadHeaderHash(bc.db), rawdb.ReadHeadFastBlockHash(bc.db)} {
+	for _, hash := range []common.Hash{rawdb.ReadHeadBlockHash(bc.db.BlockStore()), rawdb.ReadHeadHeaderHash(bc.db.BlockStore()), rawdb.ReadHeadFastBlockHash(bc.db.BlockStore())} {
 		if hash != genesis {
 			return false
 		}
@@ -701,7 +706,7 @@ func (bc *BlockChain) getFinalizedNumber(header *types.Header) uint64 {
 // assumes that the chain manager mutex is held.
 func (bc *BlockChain) loadLastState() error {
 	// Restore the last known head block
-	head := rawdb.ReadHeadBlockHash(bc.db)
+	head := rawdb.ReadHeadBlockHash(bc.db.BlockStore())
 	if head == (common.Hash{}) {
 		// Corrupt or empty database, init from scratch
 		log.Warn("Empty database, resetting chain")
@@ -723,7 +728,7 @@ func (bc *BlockChain) loadLastState() error {
 
 	// Restore the last known head header
 	headHeader := headBlock.Header()
-	if head := rawdb.ReadHeadHeaderHash(bc.db); head != (common.Hash{}) {
+	if head := rawdb.ReadHeadHeaderHash(bc.db.BlockStore()); head != (common.Hash{}) {
 		if header := bc.GetHeaderByHash(head); header != nil {
 			headHeader = header
 		}
@@ -734,7 +739,7 @@ func (bc *BlockChain) loadLastState() error {
 	bc.currentSnapBlock.Store(headBlock.Header())
 	headFastBlockGauge.Update(int64(headBlock.NumberU64()))
 
-	if head := rawdb.ReadHeadFastBlockHash(bc.db); head != (common.Hash{}) {
+	if head := rawdb.ReadHeadFastBlockHash(bc.db.BlockStore()); head != (common.Hash{}) {
 		if block := bc.GetBlockByHash(head); block != nil {
 			bc.currentSnapBlock.Store(block.Header())
 			headFastBlockGauge.Update(int64(block.NumberU64()))
@@ -1102,7 +1107,7 @@ func (bc *BlockChain) setHeadBeyondRoot(head uint64, time uint64, root common.Ha
 		// intent afterwards is full block importing, delete the chain segment
 		// between the stateful-block and the sethead target.
 		var wipe bool
-		frozen, _ := bc.db.BlockStore().Ancients()
+		frozen, _ := bc.db.Ancients()
 		if headNumber+1 < frozen {
 			wipe = pivot == nil || headNumber >= *pivot
 		}
@@ -1111,11 +1116,11 @@ func (bc *BlockChain) setHeadBeyondRoot(head uint64, time uint64, root common.Ha
 	// Rewind the header chain, deleting all block bodies until then
 	delFn := func(db ethdb.KeyValueWriter, hash common.Hash, num uint64) {
 		// Ignore the error here since light client won't hit this path
-		frozen, _ := bc.db.BlockStore().Ancients()
+		frozen, _ := bc.db.Ancients()
 		if num+1 <= frozen {
 			// Truncate all relative data(header, total difficulty, body, receipt
 			// and canonical hash) from ancient store.
-			if _, err := bc.db.BlockStore().TruncateHead(num); err != nil {
+			if _, err := bc.db.TruncateHead(num); err != nil {
 				log.Crit("Failed to truncate ancient data", "number", num, "err", err)
 			}
 			// Remove the hash <-> number mapping from the active store.
@@ -1558,9 +1563,9 @@ func (bc *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain [
 
 		// Ensure genesis is in ancients.
 		if first.NumberU64() == 1 {
-			if frozen, _ := bc.db.BlockStore().Ancients(); frozen == 0 {
+			if frozen, _ := bc.db.Ancients(); frozen == 0 {
 				td := bc.genesisBlock.Difficulty()
-				writeSize, err := rawdb.WriteAncientBlocks(bc.db.BlockStore(), []*types.Block{bc.genesisBlock}, []types.Receipts{nil}, td)
+				writeSize, err := rawdb.WriteAncientBlocks(bc.db, []*types.Block{bc.genesisBlock}, []types.Receipts{nil}, td)
 				if err != nil {
 					log.Error("Error writing genesis to ancients", "err", err)
 					return 0, err
@@ -1578,7 +1583,7 @@ func (bc *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain [
 
 		// Write all chain data to ancients.
 		td := bc.GetTd(first.Hash(), first.NumberU64())
-		writeSize, err := rawdb.WriteAncientBlocksWithBlobs(bc.db.BlockStore(), blockChain, receiptChain, td)
+		writeSize, err := rawdb.WriteAncientBlocksWithBlobs(bc.db, blockChain, receiptChain, td)
 		if err != nil {
 			log.Error("Error importing chain data to ancients", "err", err)
 			return 0, err
@@ -1586,7 +1591,7 @@ func (bc *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain [
 		size += writeSize
 
 		// Sync the ancient store explicitly to ensure all data has been flushed to disk.
-		if err := bc.db.BlockStore().Sync(); err != nil {
+		if err := bc.db.Sync(); err != nil {
 			return 0, err
 		}
 		// Update the current snap block because all block data is now present in DB.
@@ -1594,7 +1599,7 @@ func (bc *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain [
 		if !updateHead(blockChain[len(blockChain)-1]) {
 			// We end up here if the header chain has reorg'ed, and the blocks/receipts
 			// don't match the canonical chain.
-			if _, err := bc.db.BlockStore().TruncateHead(previousSnapBlock + 1); err != nil {
+			if _, err := bc.db.TruncateHead(previousSnapBlock + 1); err != nil {
 				log.Error("Can't truncate ancient store after failed insert", "err", err)
 			}
 			return 0, errSideChainReceipts
@@ -1614,7 +1619,7 @@ func (bc *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain [
 			rawdb.DeleteBlockWithoutNumber(blockBatch, block.Hash(), block.NumberU64())
 		}
 		// Delete side chain hash-to-number mappings.
-		for _, nh := range rawdb.ReadAllHashesInRange(bc.db.BlockStore(), first.NumberU64(), last.NumberU64()) {
+		for _, nh := range rawdb.ReadAllHashesInRange(bc.db, first.NumberU64(), last.NumberU64()) {
 			if _, canon := canonHashes[nh.Hash]; !canon {
 				rawdb.DeleteHeader(blockBatch, nh.Hash, nh.Number)
 			}
@@ -1800,12 +1805,6 @@ func (bc *BlockChain) writeBlockWithState(block *types.Block, receipts []*types.
 		if err := blockBatch.Write(); err != nil {
 			log.Crit("Failed to write block into disk", "err", err)
 		}
-		bc.hc.tdCache.Add(block.Hash(), externTd)
-		bc.blockCache.Add(block.Hash(), block)
-		bc.receiptsCache.Add(block.Hash(), receipts)
-		if bc.chainConfig.IsCancun(block.Number(), block.Time()) {
-			bc.sidecarsCache.Add(block.Hash(), block.Sidecars())
-		}
 		wg.Done()
 	}()
 
@@ -2234,7 +2233,6 @@ func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool) (int, error)
 			parent = bc.GetHeader(block.ParentHash(), block.NumberU64()-1)
 		}
 
-		// TODO:: state.NewDatabase internally compatible with versa is sufficient.
 		statedb, err := state.NewWithSharedPool(parent.Root, bc.stateCache, bc.snaps)
 		if err != nil {
 			return it.index, err
@@ -2284,6 +2282,8 @@ func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool) (int, error)
 		vtime := time.Since(vstart)
 		proctime := time.Since(start) // processing + validation
 
+		bc.cacheBlock(block.Hash(), block)
+
 		// Update the metrics touched during block processing and validation
 		accountReadTimer.Update(statedb.AccountReads)                   // Account reads are complete(in processing)
 		storageReadTimer.Update(statedb.StorageReads)                   // Storage reads are complete(in processing)
@@ -2396,11 +2396,26 @@ func (bc *BlockChain) updateHighestVerifiedHeader(header *types.Header) {
 	if header == nil || header.Number == nil {
 		return
 	}
-	currentBlock := bc.CurrentBlock()
-	reorg, err := bc.forker.ReorgNeededWithFastFinality(currentBlock, header)
-	if err == nil && reorg {
+	currentHeader := bc.highestVerifiedHeader.Load()
+	if currentHeader == nil {
 		bc.highestVerifiedHeader.Store(types.CopyHeader(header))
-		log.Trace("updateHighestVerifiedHeader", "number", header.Number.Uint64(), "hash", header.Hash())
+		return
+	}
+
+	newParentTD := bc.GetTd(header.ParentHash, header.Number.Uint64()-1)
+	if newParentTD == nil {
+		newParentTD = big.NewInt(0)
+	}
+	oldParentTD := bc.GetTd(currentHeader.ParentHash, currentHeader.Number.Uint64()-1)
+	if oldParentTD == nil {
+		oldParentTD = big.NewInt(0)
+	}
+	newTD := big.NewInt(0).Add(newParentTD, header.Difficulty)
+	oldTD := big.NewInt(0).Add(oldParentTD, currentHeader.Difficulty)
+
+	if newTD.Cmp(oldTD) > 0 {
+		bc.highestVerifiedHeader.Store(types.CopyHeader(header))
+		return
 	}
 }
 

core/blockchain_reader.go

@@ -231,7 +231,7 @@ func (bc *BlockChain) GetReceiptsByHash(hash common.Hash) types.Receipts {
 	if receipts, ok := bc.receiptsCache.Get(hash); ok {
 		return receipts
 	}
-	number := rawdb.ReadHeaderNumber(bc.db, hash)
+	number := rawdb.ReadHeaderNumber(bc.db.BlockStore(), hash)
 	if number == nil {
 		return nil
 	}
@@ -396,7 +396,6 @@ func (bc *BlockChain) State() (*state.StateDB, error) {
 
 // StateAt returns a new mutable state based on a particular point in time.
 func (bc *BlockChain) StateAt(root common.Hash) (*state.StateDB, error) {
-	// TODO:: state.NewDatabase internally compatible with versa is sufficient.
 	stateDb, err := state.New(root, bc.stateCache, bc.snaps)
 	if err != nil {
 		return nil, err
@@ -515,7 +514,7 @@ func (bc *BlockChain) SubscribeFinalizedHeaderEvent(ch chan<- FinalizedHeaderEve
 
 // AncientTail retrieves the tail the ancients blocks
 func (bc *BlockChain) AncientTail() (uint64, error) {
-	tail, err := bc.db.BlockStore().Tail()
+	tail, err := bc.db.Tail()
 	if err != nil {
 		return 0, err
 	}

core/blockchain_repair_test.go

@@ -26,8 +26,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/ethereum/go-ethereum/ethdb"
-
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus/ethash"
 	"github.com/ethereum/go-ethereum/core/rawdb"
@@ -1797,13 +1795,6 @@ func testRepairWithScheme(t *testing.T, tt *rewindTest, snapshots bool, scheme s
 		config.SnapshotWait = true
 	}
 	config.TriesInMemory = 128
-
-	if err = db.SetupFreezerEnv(&ethdb.FreezerEnv{
-		ChainCfg:         gspec.Config,
-		BlobExtraReserve: params.DefaultExtraReserveForBlobRequests,
-	}); err != nil {
-		t.Fatalf("Failed to create chain: %v", err)
-	}
 	chain, err := NewBlockChain(db, config, gspec, nil, engine, vm.Config{}, nil, nil)
 	if err != nil {
 		t.Fatalf("Failed to create chain: %v", err)

core/blockchain_sethead_test.go

@@ -27,8 +27,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/ethereum/go-ethereum/ethdb"
-
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus/ethash"
 	"github.com/ethereum/go-ethereum/core/rawdb"
@@ -2000,13 +1998,6 @@ func testSetHeadWithScheme(t *testing.T, tt *rewindTest, snapshots bool, scheme
 		config.SnapshotWait = true
 	}
 	config.TriesInMemory = 128
-
-	if err = db.SetupFreezerEnv(&ethdb.FreezerEnv{
-		ChainCfg:         gspec.Config,
-		BlobExtraReserve: params.DefaultExtraReserveForBlobRequests,
-	}); err != nil {
-		t.Fatalf("Failed to create chain: %v", err)
-	}
 	chain, err := NewBlockChain(db, config, gspec, nil, engine, vm.Config{}, nil, nil)
 	if err != nil {
 		t.Fatalf("Failed to create chain: %v", err)

core/chain_indexer.go

@@ -227,8 +227,8 @@ func (c *ChainIndexer) eventLoop(currentHeader *types.Header, events chan ChainH
 				// Reorg to the common ancestor if needed (might not exist in light sync mode, skip reorg then)
 				// TODO(karalabe, zsfelfoldi): This seems a bit brittle, can we detect this case explicitly?
 
-				if rawdb.ReadCanonicalHash(c.chainDb, prevHeader.Number.Uint64()) != prevHash {
-					if h := rawdb.FindCommonAncestor(c.chainDb, prevHeader, header); h != nil {
+				if rawdb.ReadCanonicalHash(c.chainDb.BlockStore(), prevHeader.Number.Uint64()) != prevHash {
+					if h := rawdb.FindCommonAncestor(c.chainDb.BlockStore(), prevHeader, header); h != nil {
 						c.newHead(h.Number.Uint64(), true)
 					}
 				}

core/chain_makers.go

@@ -397,12 +397,10 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse
 	}
 
 	// Forcibly use hash-based state scheme for retaining all nodes in disk.
-	// TODO:: ignore, only use to UT
 	triedb := triedb.NewDatabase(db, triedb.HashDefaults)
 	defer triedb.Close()
 
 	for i := 0; i < n; i++ {
-		// @TODO:: ignore, it used to UT, state.NewDatabase internally compatible with versa is sufficient.
 		statedb, err := state.New(parent.Root(), state.NewDatabaseWithNodeDB(db, triedb), nil)
 		if err != nil {
 			panic(err)

core/forkchoice.go

@@ -86,16 +86,9 @@ func (f *ForkChoice) ReorgNeeded(current *types.Header, extern *types.Header) (b
 		localTD  = f.chain.GetTd(current.Hash(), current.Number.Uint64())
 		externTd = f.chain.GetTd(extern.Hash(), extern.Number.Uint64())
 	)
-	if localTD == nil {
+	if localTD == nil || externTd == nil {
 		return false, errors.New("missing td")
 	}
-	if externTd == nil {
-		ptd := f.chain.GetTd(extern.ParentHash, extern.Number.Uint64()-1)
-		if ptd == nil {
-			return false, consensus.ErrUnknownAncestor
-		}
-		externTd = new(big.Int).Add(ptd, extern.Difficulty)
-	}
 	// Accept the new header as the chain head if the transition
 	// is already triggered. We assume all the headers after the
 	// transition come from the trusted consensus layer.

core/genesis.go

@@ -126,9 +126,7 @@ func hashAlloc(ga *types.GenesisAlloc, isVerkle bool) (common.Hash, error) {
 	}
 	// Create an ephemeral in-memory database for computing hash,
 	// all the derived states will be discarded to not pollute disk.
-	// TODO:: state.NewDatabase internally compatible with versa is sufficient.
 	db := state.NewDatabaseWithConfig(rawdb.NewMemoryDatabase(), config)
-	// TODO:: state.NewDatabase internally compatible with versa is sufficient.
 	statedb, err := state.New(types.EmptyRootHash, db, nil)
 	if err != nil {
 		return common.Hash{}, err
@@ -156,7 +154,6 @@ func flushAlloc(ga *types.GenesisAlloc, db ethdb.Database, triedb *triedb.Databa
 	if triedbConfig != nil {
 		triedbConfig.NoTries = false
 	}
-	// TODO:: state.NewDatabase internally compatible with versa is sufficient.
 	statedb, err := state.New(types.EmptyRootHash, state.NewDatabaseWithNodeDB(db, triedb), nil)
 	if err != nil {
 		return err
@@ -219,6 +216,8 @@ func (e *GenesisMismatchError) Error() string {
 // ChainOverrides contains the changes to chain config
 // Typically, these modifications involve hardforks that are not enabled on the BSC mainnet, intended for testing purposes.
 type ChainOverrides struct {
+	OverrideCancun *uint64
+	OverrideHaber  *uint64
 	OverrideBohr   *uint64
 	OverrideVerkle *uint64
 }
@@ -246,6 +245,12 @@ func SetupGenesisBlockWithOverride(db ethdb.Database, triedb *triedb.Database, g
 	}
 	applyOverrides := func(config *params.ChainConfig) {
 		if config != nil {
+			if overrides != nil && overrides.OverrideCancun != nil {
+				config.CancunTime = overrides.OverrideCancun
+			}
+			if overrides != nil && overrides.OverrideHaber != nil {
+				config.HaberTime = overrides.OverrideHaber
+			}
 			if overrides != nil && overrides.OverrideBohr != nil {
 				config.BohrTime = overrides.OverrideBohr
 			}

core/headerchain.go

@@ -97,7 +97,7 @@ func NewHeaderChain(chainDb ethdb.Database, config *params.ChainConfig, engine c
 		return nil, ErrNoGenesis
 	}
 	hc.currentHeader.Store(hc.genesisHeader)
-	if head := rawdb.ReadHeadBlockHash(chainDb); head != (common.Hash{}) {
+	if head := rawdb.ReadHeadBlockHash(chainDb.BlockStore()); head != (common.Hash{}) {
 		if chead := hc.GetHeaderByHash(head); chead != nil {
 			hc.currentHeader.Store(chead)
 		}
@@ -144,7 +144,7 @@ func (hc *HeaderChain) GetBlockNumber(hash common.Hash) *uint64 {
 	if cached, ok := hc.numberCache.Get(hash); ok {
 		return &cached
 	}
-	number := rawdb.ReadHeaderNumber(hc.chainDb, hash)
+	number := rawdb.ReadHeaderNumber(hc.chainDb.BlockStore(), hash)
 	if number != nil {
 		hc.numberCache.Add(hash, *number)
 	}
@@ -691,7 +691,7 @@ func (hc *HeaderChain) setHead(headBlock uint64, headTime uint64, updateFn Updat
 		// we don't end up with dangling daps in the database
 		var nums []uint64
 		if origin {
-			for n := num + 1; len(rawdb.ReadAllHashes(hc.chainDb.BlockStore(), n)) > 0; n++ {
+			for n := num + 1; len(rawdb.ReadAllHashes(hc.chainDb, n)) > 0; n++ {
 				nums = append([]uint64{n}, nums...) // suboptimal, but we don't really expect this path
 			}
 			origin = false
@@ -701,7 +701,7 @@ func (hc *HeaderChain) setHead(headBlock uint64, headTime uint64, updateFn Updat
 		// Remove the related data from the database on all sidechains
 		for _, num := range nums {
 			// Gather all the side fork hashes
-			hashes := rawdb.ReadAllHashes(hc.chainDb.BlockStore(), num)
+			hashes := rawdb.ReadAllHashes(hc.chainDb, num)
 			if len(hashes) == 0 {
 				// No hashes in the database whatsoever, probably frozen already
 				hashes = append(hashes, hdr.Hash())

core/rawdb/accessors_chain.go

@@ -34,15 +34,6 @@ import (
 	"golang.org/x/exp/slices"
 )
 
-// Support Multi-Database Based on Data Pattern, the Chaindata will be divided into three stores: BlockStore, StateStore, and ChainStore,
-// according to data schema and read/write behavior. When using the following data interfaces, you should take note of the following:
-//
-// 1) Block-Related Data: For CanonicalHash, Header, Body, Td, Receipts, and BlobSidecars, the Write, Delete, and Iterator
-// 	operations should carefully ensure that the database being used is BlockStore.
-// 2) Meta-Related Data: For HeaderNumber, HeadHeaderHash, HeadBlockHash, HeadFastBlockHash, and FinalizedBlockHash, the
-// 	Write and Delete operations should carefully ensure that the database being used is BlockStore.
-// 3) Ancient Data: When using a multi-database, Ancient data will use the BlockStore.
-
 // ReadCanonicalHash retrieves the hash assigned to a canonical block number.
 func ReadCanonicalHash(db ethdb.Reader, number uint64) common.Hash {
 	var data []byte
@@ -153,8 +144,8 @@ func ReadAllCanonicalHashes(db ethdb.Iteratee, from uint64, to uint64, limit int
 }
 
 // ReadHeaderNumber returns the header number assigned to a hash.
-func ReadHeaderNumber(db ethdb.MultiDatabaseReader, hash common.Hash) *uint64 {
-	data, _ := db.BlockStoreReader().Get(headerNumberKey(hash))
+func ReadHeaderNumber(db ethdb.KeyValueReader, hash common.Hash) *uint64 {
+	data, _ := db.Get(headerNumberKey(hash))
 	if len(data) != 8 {
 		return nil
 	}
@@ -179,8 +170,8 @@ func DeleteHeaderNumber(db ethdb.KeyValueWriter, hash common.Hash) {
 }
 
 // ReadHeadHeaderHash retrieves the hash of the current canonical head header.
-func ReadHeadHeaderHash(db ethdb.MultiDatabaseReader) common.Hash {
-	data, _ := db.BlockStoreReader().Get(headHeaderKey)
+func ReadHeadHeaderHash(db ethdb.KeyValueReader) common.Hash {
+	data, _ := db.Get(headHeaderKey)
 	if len(data) == 0 {
 		return common.Hash{}
 	}
@@ -195,8 +186,8 @@ func WriteHeadHeaderHash(db ethdb.KeyValueWriter, hash common.Hash) {
 }
 
 // ReadHeadBlockHash retrieves the hash of the current canonical head block.
-func ReadHeadBlockHash(db ethdb.MultiDatabaseReader) common.Hash {
-	data, _ := db.BlockStoreReader().Get(headBlockKey)
+func ReadHeadBlockHash(db ethdb.KeyValueReader) common.Hash {
+	data, _ := db.Get(headBlockKey)
 	if len(data) == 0 {
 		return common.Hash{}
 	}
@@ -211,8 +202,8 @@ func WriteHeadBlockHash(db ethdb.KeyValueWriter, hash common.Hash) {
 }
 
 // ReadHeadFastBlockHash retrieves the hash of the current fast-sync head block.
-func ReadHeadFastBlockHash(db ethdb.MultiDatabaseReader) common.Hash {
-	data, _ := db.BlockStoreReader().Get(headFastBlockKey)
+func ReadHeadFastBlockHash(db ethdb.KeyValueReader) common.Hash {
+	data, _ := db.Get(headFastBlockKey)
 	if len(data) == 0 {
 		return common.Hash{}
 	}
@@ -227,8 +218,8 @@ func WriteHeadFastBlockHash(db ethdb.KeyValueWriter, hash common.Hash) {
 }
 
 // ReadFinalizedBlockHash retrieves the hash of the finalized block.
-func ReadFinalizedBlockHash(db ethdb.MultiDatabaseReader) common.Hash {
-	data, _ := db.BlockStoreReader().Get(headFinalizedBlockKey)
+func ReadFinalizedBlockHash(db ethdb.KeyValueReader) common.Hash {
+	data, _ := db.Get(headFinalizedBlockKey)
 	if len(data) == 0 {
 		return common.Hash{}
 	}
@@ -306,7 +297,7 @@ func ReadHeaderRange(db ethdb.Reader, number uint64, count uint64) []rlp.RawValu
 		// It's ok to request block 0, 1 item
 		count = number + 1
 	}
-	limit, _ := db.BlockStoreReader().Ancients()
+	limit, _ := db.Ancients()
 	// First read live blocks
 	if i >= limit {
 		// If we need to read live blocks, we need to figure out the hash first
@@ -326,7 +317,7 @@ func ReadHeaderRange(db ethdb.Reader, number uint64, count uint64) []rlp.RawValu
 		return rlpHeaders
 	}
 	// read remaining from ancients, cap at 2M
-	data, err := db.BlockStoreReader().AncientRange(ChainFreezerHeaderTable, i+1-count, count, 2*1024*1024)
+	data, err := db.AncientRange(ChainFreezerHeaderTable, i+1-count, count, 2*1024*1024)
 	if err != nil {
 		log.Error("Failed to read headers from freezer", "err", err)
 		return rlpHeaders
@@ -477,7 +468,7 @@ func ReadCanonicalBodyRLP(db ethdb.Reader, number uint64) rlp.RawValue {
 		// Block is not in ancients, read from leveldb by hash and number.
 		// Note: ReadCanonicalHash cannot be used here because it also
 		// calls ReadAncients internally.
-		hash, _ := db.BlockStoreReader().Get(headerHashKey(number))
+		hash, _ := db.Get(headerHashKey(number))
 		data, _ = db.BlockStoreReader().Get(blockBodyKey(number, common.BytesToHash(hash)))
 		return nil
 	})
@@ -525,13 +516,6 @@ func WriteBody(db ethdb.KeyValueWriter, hash common.Hash, number uint64, body *t
 	WriteBodyRLP(db, hash, number, data)
 }
 
-// DeleteBody removes all block body data associated with a hash.
-func DeleteBody(db ethdb.KeyValueWriter, hash common.Hash, number uint64) {
-	if err := db.Delete(blockBodyKey(number, hash)); err != nil {
-		log.Crit("Failed to delete block body", "err", err)
-	}
-}
-
 func WriteDiffLayer(db ethdb.KeyValueWriter, hash common.Hash, layer *types.DiffLayer) {
 	data, err := rlp.EncodeToBytes(layer)
 	if err != nil {
@@ -570,6 +554,13 @@ func DeleteDiffLayer(db ethdb.KeyValueWriter, blockHash common.Hash) {
 	}
 }
 
+// DeleteBody removes all block body data associated with a hash.
+func DeleteBody(db ethdb.KeyValueWriter, hash common.Hash, number uint64) {
+	if err := db.Delete(blockBodyKey(number, hash)); err != nil {
+		log.Crit("Failed to delete block body", "err", err)
+	}
+}
+
 // ReadTdRLP retrieves a block's total difficulty corresponding to the hash in RLP encoding.
 func ReadTdRLP(db ethdb.Reader, hash common.Hash, number uint64) rlp.RawValue {
 	var data []byte
@@ -893,7 +884,7 @@ func WriteAncientBlocks(db ethdb.AncientWriter, blocks []*types.Block, receipts
 // ReadBlobSidecarsRLP retrieves all the transaction blobs belonging to a block in RLP encoding.
 func ReadBlobSidecarsRLP(db ethdb.Reader, hash common.Hash, number uint64) rlp.RawValue {
 	var data []byte
-	db.BlockStoreReader().ReadAncients(func(reader ethdb.AncientReaderOp) error {
+	db.ReadAncients(func(reader ethdb.AncientReaderOp) error {
 		// Check if the data is in ancients
 		if isCanon(reader, number, hash) {
 			data, _ = reader.Ancient(ChainFreezerBlobSidecarTable, number)
@@ -1102,24 +1093,24 @@ func FindCommonAncestor(db ethdb.Reader, a, b *types.Header) *types.Header {
 
 // ReadHeadHeader returns the current canonical head header.
 func ReadHeadHeader(db ethdb.Reader) *types.Header {
-	headHeaderHash := ReadHeadHeaderHash(db)
+	headHeaderHash := ReadHeadHeaderHash(db.BlockStoreReader())
 	if headHeaderHash == (common.Hash{}) {
 		return nil
 	}
-	headHeaderNumber := ReadHeaderNumber(db, headHeaderHash)
+	headHeaderNumber := ReadHeaderNumber(db.BlockStoreReader(), headHeaderHash)
 	if headHeaderNumber == nil {
 		return nil
 	}
-	return ReadHeader(db, headHeaderHash, *headHeaderNumber)
+	return ReadHeader(db.BlockStoreReader(), headHeaderHash, *headHeaderNumber)
 }
 
 // ReadHeadBlock returns the current canonical head block.
 func ReadHeadBlock(db ethdb.Reader) *types.Block {
-	headBlockHash := ReadHeadBlockHash(db)
+	headBlockHash := ReadHeadBlockHash(db.BlockStoreReader())
 	if headBlockHash == (common.Hash{}) {
 		return nil
 	}
-	headBlockNumber := ReadHeaderNumber(db, headBlockHash)
+	headBlockNumber := ReadHeaderNumber(db.BlockStoreReader(), headBlockHash)
 	if headBlockNumber == nil {
 		return nil
 	}

core/rawdb/accessors_indexes.go

@@ -42,7 +42,7 @@ func ReadTxLookupEntry(db ethdb.Reader, hash common.Hash) *uint64 {
 	}
 	// Database v4-v5 tx lookup format just stores the hash
 	if len(data) == common.HashLength {
-		return ReadHeaderNumber(db, common.BytesToHash(data))
+		return ReadHeaderNumber(db.BlockStoreReader(), common.BytesToHash(data))
 	}
 	// Finally try database v3 tx lookup format
 	var entry LegacyTxLookupEntry

core/rawdb/ancient_utils.go

@@ -18,8 +18,6 @@ package rawdb
 
 import (
 	"fmt"
-	"io"
-	"os"
 	"path/filepath"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -100,18 +98,6 @@ func inspectFreezers(db ethdb.Database) ([]freezerInfo, error) {
 			if err != nil {
 				return nil, err
 			}
-
-			file, err := os.Open(filepath.Join(datadir, StateFreezerName))
-			if err != nil {
-				return nil, err
-			}
-			defer file.Close()
-			// if state freezer folder has been pruned, there is no need for inspection
-			_, err = file.Readdirnames(1)
-			if err == io.EOF {
-				continue
-			}
-
 			f, err := NewStateFreezer(datadir, true, 0)
 			if err != nil {
 				return nil, err

core/rawdb/chain_freezer.go

@@ -58,8 +58,7 @@ type chainFreezer struct {
 	wg      sync.WaitGroup
 	trigger chan chan struct{} // Manual blocking freeze trigger, test determinism
 
-	freezeEnv    atomic.Value
-	waitEnvTimes int
+	freezeEnv atomic.Value
 
 	multiDatabase bool
 }
@@ -92,7 +91,7 @@ func (f *chainFreezer) Close() error {
 
 // readHeadNumber returns the number of chain head block. 0 is returned if the
 // block is unknown or not available yet.
-func (f *chainFreezer) readHeadNumber(db ethdb.Reader) uint64 {
+func (f *chainFreezer) readHeadNumber(db ethdb.KeyValueReader) uint64 {
 	hash := ReadHeadBlockHash(db)
 	if hash == (common.Hash{}) {
 		log.Error("Head block is not reachable")
@@ -108,7 +107,7 @@ func (f *chainFreezer) readHeadNumber(db ethdb.Reader) uint64 {
 
 // readFinalizedNumber returns the number of finalized block. 0 is returned
 // if the block is unknown or not available yet.
-func (f *chainFreezer) readFinalizedNumber(db ethdb.Reader) uint64 {
+func (f *chainFreezer) readFinalizedNumber(db ethdb.KeyValueReader) uint64 {
 	hash := ReadFinalizedBlockHash(db)
 	if hash == (common.Hash{}) {
 		return 0
@@ -123,7 +122,7 @@ func (f *chainFreezer) readFinalizedNumber(db ethdb.Reader) uint64 {
 
 // freezeThreshold returns the threshold for chain freezing. It's determined
 // by formula: max(finality, HEAD-params.FullImmutabilityThreshold).
-func (f *chainFreezer) freezeThreshold(db ethdb.Reader) (uint64, error) {
+func (f *chainFreezer) freezeThreshold(db ethdb.KeyValueReader) (uint64, error) {
 	var (
 		head      = f.readHeadNumber(db)
 		final     = f.readFinalizedNumber(db)
@@ -179,6 +178,19 @@ func (f *chainFreezer) freeze(db ethdb.KeyValueStore) {
 			}
 		}
 
+		// check freezer env first, it must wait a while when the env is necessary
+		err := f.checkFreezerEnv()
+		if err == missFreezerEnvErr {
+			log.Warn("Freezer need related env, may wait for a while", "err", err)
+			backoff = true
+			continue
+		}
+		if err != nil {
+			log.Error("Freezer check FreezerEnv err", "err", err)
+			backoff = true
+			continue
+		}
+
 		var (
 			frozen    uint64
 			threshold uint64
@@ -188,7 +200,6 @@ func (f *chainFreezer) freeze(db ethdb.KeyValueStore) {
 			hash   common.Hash
 			number *uint64
 			head   *types.Header
-			err    error
 		)
 
 		// use finalized block as the chain freeze indicator was used for multiDatabase feature, if multiDatabase is false, keep 9W blocks in db
@@ -271,18 +282,6 @@ func (f *chainFreezer) freeze(db ethdb.KeyValueStore) {
 				last = first + freezerBatchLimit
 			}
 		}
-
-		// check env first before chain freeze, it must wait when the env is necessary
-		if err := f.checkFreezerEnv(); err != nil {
-			f.waitEnvTimes++
-			if f.waitEnvTimes%30 == 0 {
-				log.Warn("Freezer need related env, may wait for a while, and it's not a issue when non-import block", "err", err)
-				return
-			}
-			backoff = true
-			continue
-		}
-
 		// Seems we have data ready to be frozen, process in usable batches
 		var (
 			start = time.Now()
@@ -545,7 +544,14 @@ func (f *chainFreezer) checkFreezerEnv() error {
 	if exist {
 		return nil
 	}
-	return missFreezerEnvErr
+	blobFrozen, err := f.TableAncients(ChainFreezerBlobSidecarTable)
+	if err != nil {
+		return err
+	}
+	if blobFrozen > 0 {
+		return missFreezerEnvErr
+	}
+	return nil
 }
 
 func isCancun(env *ethdb.FreezerEnv, num *big.Int, time uint64) bool {

core/rawdb/chain_iterator.go

@@ -35,16 +35,16 @@ import (
 // injects into the database the block hash->number mappings.
 func InitDatabaseFromFreezer(db ethdb.Database) {
 	// If we can't access the freezer or it's empty, abort
-	frozen, err := db.BlockStore().ItemAmountInAncient()
+	frozen, err := db.ItemAmountInAncient()
 	if err != nil || frozen == 0 {
 		return
 	}
 	var (
-		batch  = db.BlockStore().NewBatch()
+		batch  = db.NewBatch()
 		start  = time.Now()
 		logged = start.Add(-7 * time.Second) // Unindex during import is fast, don't double log
 		hash   common.Hash
-		offset = db.BlockStore().AncientOffSet()
+		offset = db.AncientOffSet()
 	)
 	for i := uint64(0) + offset; i < frozen+offset; i++ {
 		// We read 100K hashes at a time, for a total of 3.2M
@@ -52,7 +52,7 @@ func InitDatabaseFromFreezer(db ethdb.Database) {
 		if i+count > frozen+offset {
 			count = frozen + offset - i
 		}
-		data, err := db.BlockStore().AncientRange(ChainFreezerHashTable, i, count, 32*count)
+		data, err := db.AncientRange(ChainFreezerHashTable, i, count, 32*count)
 		if err != nil {
 			log.Crit("Failed to init database from freezer", "err", err)
 		}
@@ -100,7 +100,7 @@ func iterateTransactions(db ethdb.Database, from uint64, to uint64, reverse bool
 		number uint64
 		rlp    rlp.RawValue
 	}
-	if offset := db.BlockStore().AncientOffSet(); offset > from {
+	if offset := db.AncientOffSet(); offset > from {
 		from = offset
 	}
 	if to <= from {
@@ -122,7 +122,7 @@ func iterateTransactions(db ethdb.Database, from uint64, to uint64, reverse bool
 		}
 		defer close(rlpCh)
 		for n != end {
-			data := ReadCanonicalBodyRLP(db, n)
+			data := ReadCanonicalBodyRLP(db.BlockStore(), n)
 			// Feed the block to the aggregator, or abort on interrupt
 			select {
 			case rlpCh <- &numberRlp{n, data}:
@@ -187,7 +187,7 @@ func iterateTransactions(db ethdb.Database, from uint64, to uint64, reverse bool
 // signal received.
 func indexTransactions(db ethdb.Database, from uint64, to uint64, interrupt chan struct{}, hook func(uint64) bool, report bool) {
 	// short circuit for invalid range
-	if offset := db.BlockStore().AncientOffSet(); offset > from {
+	if offset := db.AncientOffSet(); offset > from {
 		from = offset
 	}
 	if from >= to {
@@ -286,7 +286,7 @@ func indexTransactionsForTesting(db ethdb.Database, from uint64, to uint64, inte
 // signal received.
 func unindexTransactions(db ethdb.Database, from uint64, to uint64, interrupt chan struct{}, hook func(uint64) bool, report bool) {
 	// short circuit for invalid range
-	if offset := db.BlockStore().AncientOffSet(); offset > from {
+	if offset := db.AncientOffSet(); offset > from {
 		from = offset
 	}
 	if from >= to {

core/rawdb/database.go

@@ -61,10 +61,8 @@ func (frdb *freezerdb) BlockStoreReader() ethdb.Reader {
 }
 
 func (frdb *freezerdb) BlockStoreWriter() ethdb.Writer {
-	if frdb.blockStore == nil {
-		return frdb
-	}
-	return frdb.blockStore
+	// TODO implement me
+	panic("implement me")
 }
 
 // AncientDatadir returns the path of root ancient directory.
@@ -118,13 +116,6 @@ func (frdb *freezerdb) StateStore() ethdb.Database {
 	return frdb.stateStore
 }
 
-func (frdb *freezerdb) GetStateStore() ethdb.Database {
-	if frdb.stateStore != nil {
-		return frdb.stateStore
-	}
-	return frdb
-}
-
 func (frdb *freezerdb) SetStateStore(state ethdb.Database) {
 	if frdb.stateStore != nil {
 		frdb.stateStore.Close()
@@ -263,13 +254,6 @@ func (db *nofreezedb) SetStateStore(state ethdb.Database) {
 	db.stateStore = state
 }
 
-func (db *nofreezedb) GetStateStore() ethdb.Database {
-	if db.stateStore != nil {
-		return db.stateStore
-	}
-	return db
-}
-
 func (db *nofreezedb) StateStoreReader() ethdb.Reader {
 	if db.stateStore != nil {
 		return db.stateStore
@@ -419,7 +403,6 @@ func (db *emptyfreezedb) Sync() error {
 func (db *emptyfreezedb) DiffStore() ethdb.KeyValueStore        { return db }
 func (db *emptyfreezedb) SetDiffStore(diff ethdb.KeyValueStore) {}
 func (db *emptyfreezedb) StateStore() ethdb.Database            { return db }
-func (db *emptyfreezedb) GetStateStore() ethdb.Database         { return db }
 func (db *emptyfreezedb) SetStateStore(state ethdb.Database)    {}
 func (db *emptyfreezedb) StateStoreReader() ethdb.Reader        { return db }
 func (db *emptyfreezedb) BlockStore() ethdb.Database            { return db }
@@ -535,17 +518,8 @@ func NewDatabaseWithFreezer(db ethdb.KeyValueStore, ancient string, namespace st
 
 	// Create the idle freezer instance
 	frdb, err := newChainFreezer(resolveChainFreezerDir(ancient), namespace, readonly, offset, multiDatabase)
-
-	// We are creating the freezerdb here because the validation logic for db and freezer below requires certain interfaces
-	// that need a database type. Therefore, we are pre-creating it for subsequent use.
-	freezerDb := &freezerdb{
-		ancientRoot:    ancient,
-		KeyValueStore:  db,
-		AncientStore:   frdb,
-		AncientFreezer: frdb,
-	}
 	if err != nil {
-		printChainMetadata(freezerDb)
+		printChainMetadata(db)
 		return nil, err
 	}
 
@@ -581,10 +555,10 @@ func NewDatabaseWithFreezer(db ethdb.KeyValueStore, ancient string, namespace st
 			// the freezer and the key-value store.
 			frgenesis, err := frdb.Ancient(ChainFreezerHashTable, 0)
 			if err != nil {
-				printChainMetadata(freezerDb)
+				printChainMetadata(db)
 				return nil, fmt.Errorf("failed to retrieve genesis from ancient %v", err)
 			} else if !bytes.Equal(kvgenesis, frgenesis) {
-				printChainMetadata(freezerDb)
+				printChainMetadata(db)
 				return nil, fmt.Errorf("genesis mismatch: %#x (leveldb) != %#x (ancients)", kvgenesis, frgenesis)
 			}
 			// Key-value store and freezer belong to the same network. Ensure that they
@@ -592,7 +566,7 @@ func NewDatabaseWithFreezer(db ethdb.KeyValueStore, ancient string, namespace st
 			if kvhash, _ := db.Get(headerHashKey(frozen)); len(kvhash) == 0 {
 				// Subsequent header after the freezer limit is missing from the database.
 				// Reject startup if the database has a more recent head.
-				if head := *ReadHeaderNumber(freezerDb, ReadHeadHeaderHash(freezerDb)); head > frozen-1 {
+				if head := *ReadHeaderNumber(db, ReadHeadHeaderHash(db)); head > frozen-1 {
 					// Find the smallest block stored in the key-value store
 					// in range of [frozen, head]
 					var number uint64
@@ -602,7 +576,7 @@ func NewDatabaseWithFreezer(db ethdb.KeyValueStore, ancient string, namespace st
 						}
 					}
 					// We are about to exit on error. Print database metadata before exiting
-					printChainMetadata(freezerDb)
+					printChainMetadata(db)
 					return nil, fmt.Errorf("gap in the chain between ancients [0 - #%d] and leveldb [#%d - #%d] ",
 						frozen-1, number, head)
 				}
@@ -617,11 +591,11 @@ func NewDatabaseWithFreezer(db ethdb.KeyValueStore, ancient string, namespace st
 			// store, otherwise we'll end up missing data. We check block #1 to decide
 			// if we froze anything previously or not, but do take care of databases with
 			// only the genesis block.
-			if ReadHeadHeaderHash(freezerDb) != common.BytesToHash(kvgenesis) {
+			if ReadHeadHeaderHash(db) != common.BytesToHash(kvgenesis) {
 				// Key-value store contains more data than the genesis block, make sure we
 				// didn't freeze anything yet.
 				if kvblob, _ := db.Get(headerHashKey(1)); len(kvblob) == 0 {
-					printChainMetadata(freezerDb)
+					printChainMetadata(db)
 					return nil, errors.New("ancient chain segments already extracted, please set --datadir.ancient to the correct path")
 				}
 				// Block #1 is still in the database, we're allowed to init a new freezer
@@ -643,7 +617,12 @@ func NewDatabaseWithFreezer(db ethdb.KeyValueStore, ancient string, namespace st
 			frdb.wg.Done()
 		}()
 	}
-	return freezerDb, nil
+	return &freezerdb{
+		ancientRoot:    ancient,
+		KeyValueStore:  db,
+		AncientStore:   frdb,
+		AncientFreezer: frdb,
+	}, nil
 }
 
 // NewMemoryDatabase creates an ephemeral in-memory key-value database without a
@@ -1259,7 +1238,7 @@ func DeleteTrieState(db ethdb.Database) error {
 }
 
 // printChainMetadata prints out chain metadata to stderr.
-func printChainMetadata(db ethdb.Reader) {
+func printChainMetadata(db ethdb.KeyValueStore) {
 	fmt.Fprintf(os.Stderr, "Chain metadata\n")
 	for _, v := range ReadChainMetadata(db) {
 		fmt.Fprintf(os.Stderr, "  %s\n", strings.Join(v, ": "))
@@ -1270,7 +1249,7 @@ func printChainMetadata(db ethdb.Reader) {
 // ReadChainMetadata returns a set of key/value pairs that contains information
 // about the database chain status. This can be used for diagnostic purposes
 // when investigating the state of the node.
-func ReadChainMetadata(db ethdb.Reader) [][]string {
+func ReadChainMetadata(db ethdb.KeyValueStore) [][]string {
 	pp := func(val *uint64) string {
 		if val == nil {
 			return "<nil>"
@@ -1292,3 +1271,26 @@ func ReadChainMetadata(db ethdb.Reader) [][]string {
 	}
 	return data
 }
+
+func ReadChainMetadataFromMultiDatabase(db ethdb.Database) [][]string {
+	pp := func(val *uint64) string {
+		if val == nil {
+			return "<nil>"
+		}
+		return fmt.Sprintf("%d (%#x)", *val, *val)
+	}
+	data := [][]string{
+		{"databaseVersion", pp(ReadDatabaseVersion(db))},
+		{"headBlockHash", fmt.Sprintf("%v", ReadHeadBlockHash(db.BlockStore()))},
+		{"headFastBlockHash", fmt.Sprintf("%v", ReadHeadFastBlockHash(db.BlockStore()))},
+		{"headHeaderHash", fmt.Sprintf("%v", ReadHeadHeaderHash(db.BlockStore()))},
+		{"lastPivotNumber", pp(ReadLastPivotNumber(db))},
+		{"len(snapshotSyncStatus)", fmt.Sprintf("%d bytes", len(ReadSnapshotSyncStatus(db)))},
+		{"snapshotDisabled", fmt.Sprintf("%v", ReadSnapshotDisabled(db))},
+		{"snapshotJournal", fmt.Sprintf("%d bytes", len(ReadSnapshotJournal(db)))},
+		{"snapshotRecoveryNumber", pp(ReadSnapshotRecoveryNumber(db))},
+		{"snapshotRoot", fmt.Sprintf("%v", ReadSnapshotRoot(db))},
+		{"txIndexTail", pp(ReadTxIndexTail(db))},
+	}
+	return data
+}

core/rawdb/freezer.go

@@ -541,6 +541,41 @@ func gcKvStore(db ethdb.KeyValueStore, ancients []common.Hash, first uint64, fro
 	}
 	batch.Reset()
 
+	// Step into the future and delete and dangling side chains
+	if frozen > 0 {
+		tip := frozen
+		nfdb := &nofreezedb{KeyValueStore: db}
+		for len(dangling) > 0 {
+			drop := make(map[common.Hash]struct{})
+			for _, hash := range dangling {
+				log.Debug("Dangling parent from freezer", "number", tip-1, "hash", hash)
+				drop[hash] = struct{}{}
+			}
+			children := ReadAllHashes(db, tip)
+			for i := 0; i < len(children); i++ {
+				// Dig up the child and ensure it's dangling
+				child := ReadHeader(nfdb, children[i], tip)
+				if child == nil {
+					log.Error("Missing dangling header", "number", tip, "hash", children[i])
+					continue
+				}
+				if _, ok := drop[child.ParentHash]; !ok {
+					children = append(children[:i], children[i+1:]...)
+					i--
+					continue
+				}
+				// Delete all block data associated with the child
+				log.Debug("Deleting dangling block", "number", tip, "hash", children[i], "parent", child.ParentHash)
+				DeleteBlock(batch, children[i], tip)
+			}
+			dangling = children
+			tip++
+		}
+		if err := batch.Write(); err != nil {
+			log.Crit("Failed to delete dangling side blocks", "err", err)
+		}
+	}
+
 	// Log something friendly for the user
 	context := []interface{}{
 		"blocks", frozen - first, "elapsed", common.PrettyDuration(time.Since(start)), "number", frozen - 1,

core/rawdb/freezer_table.go

@@ -127,11 +127,6 @@ func newFreezerTable(path, name string, disableSnappy, readonly bool) (*freezerT
 	return newTable(path, name, metrics.NilMeter{}, metrics.NilMeter{}, metrics.NilGauge{}, freezerTableSize, disableSnappy, readonly)
 }
 
-// newAdditionTable opens the given path as a addition table.
-func newAdditionTable(path, name string, disableSnappy, readonly bool) (*freezerTable, error) {
-	return openAdditionTable(path, name, metrics.NilMeter{}, metrics.NilMeter{}, metrics.NilGauge{}, freezerTableSize, disableSnappy, readonly)
-}
-
 // newTable opens a freezer table, creating the data and index files if they are
 // non-existent. Both files are truncated to the shortest common length to ensure
 // they don't go out of sync.

core/rawdb/prunedfreezer.go

@@ -8,8 +8,6 @@ import (
 	"sync/atomic"
 	"time"
 
-	"golang.org/x/exp/slices"
-
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
@@ -68,49 +66,28 @@ func newPrunedFreezer(datadir string, db ethdb.KeyValueStore, offset uint64) (*p
 
 // repair init frozen , compatible disk-ancientdb and pruner-block-tool.
 func (f *prunedfreezer) repair(datadir string) error {
+	offset := atomic.LoadUint64(&f.frozen)
 	// compatible freezer
-	minItems := uint64(math.MaxUint64)
+	min := uint64(math.MaxUint64)
 	for name, disableSnappy := range chainFreezerNoSnappy {
-		var (
-			table *freezerTable
-			err   error
-		)
-		if slices.Contains(additionTables, name) {
-			table, err = newAdditionTable(datadir, name, disableSnappy, false)
-		} else {
-			table, err = newFreezerTable(datadir, name, disableSnappy, false)
-		}
+		table, err := newFreezerTable(datadir, name, disableSnappy, false)
 		if err != nil {
 			return err
 		}
-		// addition tables only align head
-		if slices.Contains(additionTables, name) {
-			if EmptyTable(table) {
-				continue
-			}
-		}
 		items := table.items.Load()
-		if minItems > items {
-			minItems = items
+		if min > items {
+			min = items
 		}
 		table.Close()
 	}
+	log.Info("Read ancientdb item counts", "items", min)
+	offset += min
 
-	// If minItems is non-zero, it indicates that the chain freezer was previously enabled, and we should use minItems as the current frozen value.
-	// If minItems is zero, it indicates that the pruneAncient was previously enabled, and we should continue using frozen
-	//	(retrieved from CurrentAncientFreezer) as the current frozen value.
-	offset := minItems
-	if offset == 0 {
-		// no item in ancientDB, init `offset` to the `f.frozen`
-		offset = atomic.LoadUint64(&f.frozen)
+	if frozen := ReadFrozenOfAncientFreezer(f.db); frozen > offset {
+		offset = frozen
 	}
-	log.Info("Read ancientdb item counts", "items", minItems, "offset", offset)
 
-	// FrozenOfAncientFreezer is the progress of the last prune-freezer freeze.
-	frozenInDB := ReadFrozenOfAncientFreezer(f.db)
-	maxOffset := max(offset, frozenInDB)
-
-	atomic.StoreUint64(&f.frozen, maxOffset)
+	atomic.StoreUint64(&f.frozen, offset)
 	if err := f.Sync(); err != nil {
 		return nil
 	}
@@ -322,8 +299,9 @@ func (f *prunedfreezer) freeze() {
 				log.Error("Append ancient err", "number", f.frozen, "hash", hash, "err", err)
 				break
 			}
-			// may include common.Hash{}, will be delete in gcKvStore
-			ancients = append(ancients, hash)
+			if hash != (common.Hash{}) {
+				ancients = append(ancients, hash)
+			}
 		}
 		// Batch of blocks have been frozen, flush them before wiping from leveldb
 		if err := f.Sync(); err != nil {

core/rawdb/table.go

@@ -251,10 +251,6 @@ func (t *table) SetStateStore(state ethdb.Database) {
 	panic("not implement")
 }
 
-func (t *table) GetStateStore() ethdb.Database {
-	return nil
-}
-
 func (t *table) StateStoreReader() ethdb.Reader {
 	return nil
 }

core/state/pruner/pruner.go

@@ -232,7 +232,6 @@ func pruneAll(maindb ethdb.Database, g *core.Genesis) error {
 		}
 		log.Info("Database compaction finished", "elapsed", common.PrettyDuration(time.Since(cstart)))
 	}
-	// TODO:: ignore, versa has its own prunner
 	statedb, _ := state.New(common.Hash{}, state.NewDatabase(maindb), nil)
 	for addr, account := range g.Alloc {
 		statedb.AddBalance(addr, uint256.MustFromBig(account.Balance))

core/state/snapshot/snapshot.go

@@ -205,8 +205,6 @@ type Tree struct {
 //     state trie.
 //   - otherwise, the entire snapshot is considered invalid and will be recreated on
 //     a background thread.
-//
-// TODO:: if use versa, set SnapshotLimit == 0, will forbidden to use
 func New(config Config, diskdb ethdb.KeyValueStore, triedb *triedb.Database, root common.Hash, cap int, withoutTrie bool) (*Tree, error) {
 	snap := &Tree{
 		config:   config,

core/state/statedb.go

@@ -933,8 +933,8 @@ func (s *StateDB) copyInternal(doPrefetch bool) *StateDB {
 	// along with their original values.
 	state.accounts = copySet(s.accounts)
 	state.storages = copy2DSet(s.storages)
-	state.accountsOrigin = copySet(s.accountsOrigin)
-	state.storagesOrigin = copy2DSet(s.storagesOrigin)
+	state.accountsOrigin = copySet(state.accountsOrigin)
+	state.storagesOrigin = copy2DSet(state.storagesOrigin)
 
 	// Deep copy the logs occurred in the scope of block
 	for hash, logs := range s.logs {

core/state/sync.go

@@ -25,7 +25,7 @@ import (
 )
 
 // NewStateSync creates a new state trie download scheduler.
-func NewStateSync(root common.Hash, database ethdb.Database, onLeaf func(keys [][]byte, leaf []byte) error, scheme string) *trie.Sync {
+func NewStateSync(root common.Hash, database ethdb.KeyValueReader, onLeaf func(keys [][]byte, leaf []byte) error, scheme string) *trie.Sync {
 	// Register the storage slot callback if the external callback is specified.
 	var onSlot func(keys [][]byte, path []byte, leaf []byte, parent common.Hash, parentPath []byte) error
 	if onLeaf != nil {

core/state/sync_test.go

@@ -268,7 +268,7 @@ func testIterativeStateSync(t *testing.T, count int, commit bool, bypath bool, s
 			}
 		}
 		batch := dstDb.NewBatch()
-		if err := sched.Commit(batch, nil); err != nil {
+		if err := sched.Commit(batch); err != nil {
 			t.Fatalf("failed to commit data: %v", err)
 		}
 		batch.Write()
@@ -369,7 +369,7 @@ func testIterativeDelayedStateSync(t *testing.T, scheme string) {
 			nodeProcessed = len(nodeResults)
 		}
 		batch := dstDb.NewBatch()
-		if err := sched.Commit(batch, nil); err != nil {
+		if err := sched.Commit(batch); err != nil {
 			t.Fatalf("failed to commit data: %v", err)
 		}
 		batch.Write()
@@ -469,7 +469,7 @@ func testIterativeRandomStateSync(t *testing.T, count int, scheme string) {
 			}
 		}
 		batch := dstDb.NewBatch()
-		if err := sched.Commit(batch, nil); err != nil {
+		if err := sched.Commit(batch); err != nil {
 			t.Fatalf("failed to commit data: %v", err)
 		}
 		batch.Write()
@@ -575,7 +575,7 @@ func testIterativeRandomDelayedStateSync(t *testing.T, scheme string) {
 			}
 		}
 		batch := dstDb.NewBatch()
-		if err := sched.Commit(batch, nil); err != nil {
+		if err := sched.Commit(batch); err != nil {
 			t.Fatalf("failed to commit data: %v", err)
 		}
 		batch.Write()
@@ -688,7 +688,7 @@ func testIncompleteStateSync(t *testing.T, scheme string) {
 			}
 		}
 		batch := dstDb.NewBatch()
-		if err := sched.Commit(batch, nil); err != nil {
+		if err := sched.Commit(batch); err != nil {
 			t.Fatalf("failed to commit data: %v", err)
 		}
 		batch.Write()

core/systemcontracts/haber_fix/types.go

@@ -9,11 +9,3 @@ var (
 	//go:embed chapel/SlashContract
 	ChapelSlashContract string
 )
-
-// contract codes for Mainnet upgrade
-var (
-	//go:embed mainnet/ValidatorContract
-	MainnetValidatorContract string
-	//go:embed mainnet/SlashContract
-	MainnetSlashContract string
-)

core/systemcontracts/upgrade.go

@@ -4,7 +4,6 @@ import (
 	"encoding/hex"
 	"fmt"
 	"math/big"
-	"strings"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/state"
@@ -705,33 +704,17 @@ func init() {
 		},
 	}
 
-	haberFixUpgrade[mainNet] = &Upgrade{
-		UpgradeName: "haberFix",
-		Configs: []*UpgradeConfig{
-			{
-				ContractAddr: common.HexToAddress(ValidatorContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/b743ce3f1f1e94c349b175cd6593bc263463b33b",
-				Code:         haberFix.MainnetValidatorContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(SlashContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/b743ce3f1f1e94c349b175cd6593bc263463b33b",
-				Code:         haberFix.MainnetSlashContract,
-			},
-		},
-	}
-
 	haberFixUpgrade[chapelNet] = &Upgrade{
 		UpgradeName: "haberFix",
 		Configs: []*UpgradeConfig{
 			{
 				ContractAddr: common.HexToAddress(ValidatorContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/b743ce3f1f1e94c349b175cd6593bc263463b33b",
+				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/2d6372ddba77902ef01e45887a425938376d5a5c",
 				Code:         haberFix.ChapelValidatorContract,
 			},
 			{
 				ContractAddr: common.HexToAddress(SlashContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/b743ce3f1f1e94c349b175cd6593bc263463b33b",
+				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/2d6372ddba77902ef01e45887a425938376d5a5c",
 				Code:         haberFix.ChapelSlashContract,
 			},
 		},
@@ -838,7 +821,7 @@ func applySystemContractUpgrade(upgrade *Upgrade, blockNumber *big.Int, statedb
 			}
 		}
 
-		newContractCode, err := hex.DecodeString(strings.TrimSpace(cfg.Code))
+		newContractCode, err := hex.DecodeString(cfg.Code)
 		if err != nil {
 			panic(fmt.Errorf("failed to decode new contract code: %s", err.Error()))
 		}

core/vm/runtime/runtime.go

@@ -115,7 +115,6 @@ func Execute(code, input []byte, cfg *Config) ([]byte, *state.StateDB, error) {
 	setDefaults(cfg)
 
 	if cfg.State == nil {
-		// TODO:: state.NewDatabase internally compatible with versa is sufficient.
 		cfg.State, _ = state.New(types.EmptyRootHash, state.NewDatabase(rawdb.NewMemoryDatabase()), nil)
 	}
 	var (
@@ -150,7 +149,6 @@ func Create(input []byte, cfg *Config) ([]byte, common.Address, uint64, error) {
 	setDefaults(cfg)
 
 	if cfg.State == nil {
-		// TODO:: state.NewDatabase internally compatible with versa is sufficient.
 		cfg.State, _ = state.New(types.EmptyRootHash, state.NewDatabase(rawdb.NewMemoryDatabase()), nil)
 	}
 	var (

core/vote/vote_manager.go

@@ -4,11 +4,9 @@ import (
 	"bytes"
 	"fmt"
 	"sync"
-	"time"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus"
-	"github.com/ethereum/go-ethereum/consensus/parlia"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/eth/downloader"
@@ -141,15 +139,6 @@ func (voteManager *VoteManager) loop() {
 			}
 
 			curHead := cHead.Block.Header()
-			if p, ok := voteManager.engine.(*parlia.Parlia); ok {
-				nextBlockMinedTime := time.Unix(int64((curHead.Time + p.Period())), 0)
-				timeForBroadcast := 50 * time.Millisecond // enough to broadcast a vote
-				if time.Now().Add(timeForBroadcast).After(nextBlockMinedTime) {
-					log.Warn("too late to vote", "Head.Time(Second)", curHead.Time, "Now(Millisecond)", time.Now().UnixMilli())
-					continue
-				}
-			}
-
 			// Check if cur validator is within the validatorSet at curHead
 			if !voteManager.engine.IsActiveValidatorAt(voteManager.chain, curHead,
 				func(bLSPublicKey *types.BLSPublicKey) bool {

eth/backend.go

@@ -185,6 +185,14 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) {
 	}
 	// Override the chain config with provided settings.
 	var overrides core.ChainOverrides
+	if config.OverrideCancun != nil {
+		chainConfig.CancunTime = config.OverrideCancun
+		overrides.OverrideCancun = config.OverrideCancun
+	}
+	if config.OverrideHaber != nil {
+		chainConfig.HaberTime = config.OverrideHaber
+		overrides.OverrideHaber = config.OverrideHaber
+	}
 	if config.OverrideBohr != nil {
 		chainConfig.BohrTime = config.OverrideBohr
 		overrides.OverrideBohr = config.OverrideBohr

eth/downloader/downloader.go

@@ -558,8 +558,8 @@ func (d *Downloader) syncWithPeer(p *peerConnection, hash common.Hash, td, ttd *
 		} else {
 			d.ancientLimit = 0
 		}
-		frozen, _ := d.stateDB.BlockStore().Ancients() // Ignore the error here since light client can also hit here.
-		itemAmountInAncient, _ := d.stateDB.BlockStore().ItemAmountInAncient()
+		frozen, _ := d.stateDB.Ancients() // Ignore the error here since light client can also hit here.
+		itemAmountInAncient, _ := d.stateDB.ItemAmountInAncient()
 		// If a part of blockchain data has already been written into active store,
 		// disable the ancient style insertion explicitly.
 		if origin >= frozen && itemAmountInAncient != 0 {
@@ -1671,9 +1671,9 @@ func (d *Downloader) reportSnapSyncProgress(force bool) {
 	}
 	// Don't report anything until we have a meaningful progress
 	var (
-		headerBytes, _  = d.stateDB.BlockStore().AncientSize(rawdb.ChainFreezerHeaderTable)
-		bodyBytes, _    = d.stateDB.BlockStore().AncientSize(rawdb.ChainFreezerBodiesTable)
-		receiptBytes, _ = d.stateDB.BlockStore().AncientSize(rawdb.ChainFreezerReceiptTable)
+		headerBytes, _  = d.stateDB.AncientSize(rawdb.ChainFreezerHeaderTable)
+		bodyBytes, _    = d.stateDB.AncientSize(rawdb.ChainFreezerBodiesTable)
+		receiptBytes, _ = d.stateDB.AncientSize(rawdb.ChainFreezerReceiptTable)
 	)
 	syncedBytes := common.StorageSize(headerBytes + bodyBytes + receiptBytes)
 	if syncedBytes == 0 {

eth/ethconfig/config.go

@@ -188,6 +188,12 @@ type Config struct {
 	// send-transaction variants. The unit is ether.
 	RPCTxFeeCap float64
 
+	// OverrideCancun (TODO: remove after the fork)
+	OverrideCancun *uint64 `toml:",omitempty"`
+
+	// OverrideHaber (TODO: remove after the fork)
+	OverrideHaber *uint64 `toml:",omitempty"`
+
 	// OverrideBohr (TODO: remove after the fork)
 	OverrideBohr *uint64 `toml:",omitempty"`
 

eth/ethconfig/gen_config.go

@@ -70,6 +70,8 @@ func (c Config) MarshalTOML() (interface{}, error) {
 		RPCGasCap               uint64
 		RPCEVMTimeout           time.Duration
 		RPCTxFeeCap             float64
+		OverrideCancun          *uint64 `toml:",omitempty"`
+		OverrideHaber           *uint64 `toml:",omitempty"`
 		OverrideBohr            *uint64 `toml:",omitempty"`
 		OverrideVerkle          *uint64 `toml:",omitempty"`
 		BlobExtraReserve        uint64
@@ -128,6 +130,8 @@ func (c Config) MarshalTOML() (interface{}, error) {
 	enc.RPCGasCap = c.RPCGasCap
 	enc.RPCEVMTimeout = c.RPCEVMTimeout
 	enc.RPCTxFeeCap = c.RPCTxFeeCap
+	enc.OverrideCancun = c.OverrideCancun
+	enc.OverrideHaber = c.OverrideHaber
 	enc.OverrideBohr = c.OverrideBohr
 	enc.OverrideVerkle = c.OverrideVerkle
 	enc.BlobExtraReserve = c.BlobExtraReserve
@@ -190,6 +194,8 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
 		RPCGasCap               *uint64
 		RPCEVMTimeout           *time.Duration
 		RPCTxFeeCap             *float64
+		OverrideCancun          *uint64 `toml:",omitempty"`
+		OverrideHaber           *uint64 `toml:",omitempty"`
 		OverrideBohr            *uint64 `toml:",omitempty"`
 		OverrideVerkle          *uint64 `toml:",omitempty"`
 		BlobExtraReserve        *uint64
@@ -357,6 +363,12 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
 	if dec.RPCTxFeeCap != nil {
 		c.RPCTxFeeCap = *dec.RPCTxFeeCap
 	}
+	if dec.OverrideCancun != nil {
+		c.OverrideCancun = dec.OverrideCancun
+	}
+	if dec.OverrideHaber != nil {
+		c.OverrideHaber = dec.OverrideHaber
+	}
 	if dec.OverrideBohr != nil {
 		c.OverrideBohr = dec.OverrideBohr
 	}

eth/protocols/snap/sync.go

@@ -409,8 +409,8 @@ type SyncPeer interface {
 //   - The peer delivers a stale response after a previous timeout
 //   - The peer delivers a refusal to serve the requested state
 type Syncer struct {
-	db     ethdb.Database // Database to store the trie nodes into (and dedup)
-	scheme string         // Node scheme used in node database
+	db     ethdb.KeyValueStore // Database to store the trie nodes into (and dedup)
+	scheme string              // Node scheme used in node database
 
 	root    common.Hash    // Current state trie root being synced
 	tasks   []*accountTask // Current account task set being synced
@@ -478,7 +478,7 @@ type Syncer struct {
 
 // NewSyncer creates a new snapshot syncer to download the Ethereum state over the
 // snap protocol.
-func NewSyncer(db ethdb.Database, scheme string) *Syncer {
+func NewSyncer(db ethdb.KeyValueStore, scheme string) *Syncer {
 	return &Syncer{
 		db:     db,
 		scheme: scheme,
@@ -719,11 +719,11 @@ func (s *Syncer) Sync(root common.Hash, cancel chan struct{}) error {
 
 // cleanPath is used to remove the dangling nodes in the stackTrie.
 func (s *Syncer) cleanPath(batch ethdb.Batch, owner common.Hash, path []byte) {
-	if owner == (common.Hash{}) && rawdb.ExistsAccountTrieNode(s.db.StateStoreReader(), path) {
+	if owner == (common.Hash{}) && rawdb.ExistsAccountTrieNode(s.db, path) {
 		rawdb.DeleteAccountTrieNode(batch, path)
 		deletionGauge.Inc(1)
 	}
-	if owner != (common.Hash{}) && rawdb.ExistsStorageTrieNode(s.db.StateStoreReader(), owner, path) {
+	if owner != (common.Hash{}) && rawdb.ExistsStorageTrieNode(s.db, owner, path) {
 		rawdb.DeleteStorageTrieNode(batch, owner, path)
 		deletionGauge.Inc(1)
 	}
@@ -735,7 +735,6 @@ func (s *Syncer) cleanPath(batch ethdb.Batch, owner common.Hash, path []byte) {
 func (s *Syncer) loadSyncStatus() {
 	var progress SyncProgress
 
-	stateDiskDB := s.db.GetStateStore()
 	if status := rawdb.ReadSnapshotSyncStatus(s.db); status != nil {
 		if err := json.Unmarshal(status, &progress); err != nil {
 			log.Error("Failed to decode snap sync status", "err", err)
@@ -748,7 +747,7 @@ func (s *Syncer) loadSyncStatus() {
 				task := task // closure for task.genBatch in the stacktrie writer callback
 
 				task.genBatch = ethdb.HookedBatch{
-					Batch: stateDiskDB.NewBatch(),
+					Batch: s.db.NewBatch(),
 					OnPut: func(key []byte, value []byte) {
 						s.accountBytes += common.StorageSize(len(key) + len(value))
 					},
@@ -774,7 +773,7 @@ func (s *Syncer) loadSyncStatus() {
 						subtask := subtask // closure for subtask.genBatch in the stacktrie writer callback
 
 						subtask.genBatch = ethdb.HookedBatch{
-							Batch: stateDiskDB.NewBatch(),
+							Batch: s.db.NewBatch(),
 							OnPut: func(key []byte, value []byte) {
 								s.storageBytes += common.StorageSize(len(key) + len(value))
 							},
@@ -842,7 +841,7 @@ func (s *Syncer) loadSyncStatus() {
 			last = common.MaxHash
 		}
 		batch := ethdb.HookedBatch{
-			Batch: stateDiskDB.NewBatch(),
+			Batch: s.db.NewBatch(),
 			OnPut: func(key []byte, value []byte) {
 				s.accountBytes += common.StorageSize(len(key) + len(value))
 			},
@@ -1895,7 +1894,7 @@ func (s *Syncer) processAccountResponse(res *accountResponse) {
 		}
 		// Check if the account is a contract with an unknown storage trie
 		if account.Root != types.EmptyRootHash {
-			if !rawdb.HasTrieNode(s.db.StateStoreReader(), res.hashes[i], nil, account.Root, s.scheme) {
+			if !rawdb.HasTrieNode(s.db, res.hashes[i], nil, account.Root, s.scheme) {
 				// If there was a previous large state retrieval in progress,
 				// don't restart it from scratch. This happens if a sync cycle
 				// is interrupted and resumed later. However, *do* update the
@@ -1987,25 +1986,12 @@ func (s *Syncer) processStorageResponse(res *storageResponse) {
 	if res.subTask != nil {
 		res.subTask.req = nil
 	}
-
-	var usingMultDatabase bool
 	batch := ethdb.HookedBatch{
-		Batch: s.db.GetStateStore().NewBatch(),
+		Batch: s.db.NewBatch(),
 		OnPut: func(key []byte, value []byte) {
 			s.storageBytes += common.StorageSize(len(key) + len(value))
 		},
 	}
-	var snapBatch ethdb.HookedBatch
-	if s.db.StateStore() != nil {
-		usingMultDatabase = true
-		snapBatch = ethdb.HookedBatch{
-			Batch: s.db.NewBatch(),
-			OnPut: func(key []byte, value []byte) {
-				s.storageBytes += common.StorageSize(len(key) + len(value))
-			},
-		}
-	}
-
 	var (
 		slots           int
 		oldStorageBytes = s.storageBytes
@@ -2075,7 +2061,7 @@ func (s *Syncer) processStorageResponse(res *storageResponse) {
 					}
 					// Our first task is the one that was just filled by this response.
 					batch := ethdb.HookedBatch{
-						Batch: s.db.GetStateStore().NewBatch(),
+						Batch: s.db.NewBatch(),
 						OnPut: func(key []byte, value []byte) {
 							s.storageBytes += common.StorageSize(len(key) + len(value))
 						},
@@ -2102,7 +2088,7 @@ func (s *Syncer) processStorageResponse(res *storageResponse) {
 					})
 					for r.Next() {
 						batch := ethdb.HookedBatch{
-							Batch: s.db.GetStateStore().NewBatch(),
+							Batch: s.db.NewBatch(),
 							OnPut: func(key []byte, value []byte) {
 								s.storageBytes += common.StorageSize(len(key) + len(value))
 							},
@@ -2198,11 +2184,8 @@ func (s *Syncer) processStorageResponse(res *storageResponse) {
 		// outdated during the sync, but it can be fixed later during the
 		// snapshot generation.
 		for j := 0; j < len(res.hashes[i]); j++ {
-			if usingMultDatabase {
-				rawdb.WriteStorageSnapshot(snapBatch, account, res.hashes[i][j], res.slots[i][j])
-			} else {
-				rawdb.WriteStorageSnapshot(batch, account, res.hashes[i][j], res.slots[i][j])
-			}
+			rawdb.WriteStorageSnapshot(batch, account, res.hashes[i][j], res.slots[i][j])
+
 			// If we're storing large contracts, generate the trie nodes
 			// on the fly to not trash the gluing points
 			if i == len(res.hashes)-1 && res.subTask != nil {
@@ -2222,7 +2205,7 @@ func (s *Syncer) processStorageResponse(res *storageResponse) {
 			// If the chunk's root is an overflown but full delivery,
 			// clear the heal request.
 			accountHash := res.accounts[len(res.accounts)-1]
-			if root == res.subTask.root && rawdb.HasStorageTrieNode(s.db.StateStoreReader(), accountHash, nil, root) {
+			if root == res.subTask.root && rawdb.HasStorageTrieNode(s.db, accountHash, nil, root) {
 				for i, account := range res.mainTask.res.hashes {
 					if account == accountHash {
 						res.mainTask.needHeal[i] = false
@@ -2242,11 +2225,6 @@ func (s *Syncer) processStorageResponse(res *storageResponse) {
 	if err := batch.Write(); err != nil {
 		log.Crit("Failed to persist storage slots", "err", err)
 	}
-	if usingMultDatabase {
-		if err := snapBatch.Write(); err != nil {
-			log.Crit("Failed to persist storage slots", "err", err)
-		}
-	}
 	s.storageSynced += uint64(slots)
 
 	log.Debug("Persisted set of storage slots", "accounts", len(res.hashes), "slots", slots, "bytes", s.storageBytes-oldStorageBytes)
@@ -2345,25 +2323,12 @@ func (s *Syncer) commitHealer(force bool) {
 		return
 	}
 	batch := s.db.NewBatch()
-	var stateBatch ethdb.Batch
-	var err error
-	if s.db.StateStore() != nil {
-		stateBatch = s.db.StateStore().NewBatch()
-		err = s.healer.scheduler.Commit(batch, stateBatch)
-	} else {
-		err = s.healer.scheduler.Commit(batch, nil)
-	}
-	if err != nil {
+	if err := s.healer.scheduler.Commit(batch); err != nil {
 		log.Error("Failed to commit healing data", "err", err)
 	}
 	if err := batch.Write(); err != nil {
 		log.Crit("Failed to persist healing data", "err", err)
 	}
-	if s.db.StateStore() != nil {
-		if err := stateBatch.Write(); err != nil {
-			log.Crit("Failed to persist healing data", "err", err)
-		}
-	}
 	log.Debug("Persisted set of healing data", "type", "trienodes", "bytes", common.StorageSize(batch.ValueSize()))
 }
 

eth/state_accessor.go

@@ -71,9 +71,7 @@ func (eth *Ethereum) hashState(ctx context.Context, block *types.Block, reexec u
 			// the internal junks created by tracing will be persisted into the disk.
 			// TODO(rjl493456442), clean cache is disabled to prevent memory leak,
 			// please re-enable it for better performance.
-			// TODO:: state.NewDatabase internally compatible with versa is sufficient.
 			database = state.NewDatabaseWithConfig(eth.chainDb, triedb.HashDefaults)
-			// TODO:: state.NewDatabase internally compatible with versa is sufficient.
 			if statedb, err = state.New(block.Root(), database, nil); err == nil {
 				log.Info("Found disk backend for state trie", "root", block.Root(), "number", block.Number())
 				return statedb, noopReleaser, nil
@@ -93,16 +91,13 @@ func (eth *Ethereum) hashState(ctx context.Context, block *types.Block, reexec u
 		// the internal junks created by tracing will be persisted into the disk.
 		// TODO(rjl493456442), clean cache is disabled to prevent memory leak,
 		// please re-enable it for better performance.
-		// TODO:: if use versa, tdb == nil
 		tdb = triedb.NewDatabase(eth.chainDb, triedb.HashDefaults)
-		// TODO:: state.NewDatabase internally compatible with versa is sufficient.
 		database = state.NewDatabaseWithNodeDB(eth.chainDb, tdb)
 
 		// If we didn't check the live database, do check state over ephemeral database,
 		// otherwise we would rewind past a persisted block (specific corner case is
 		// chain tracing from the genesis).
 		if !readOnly {
-			// TODO:: state.NewDatabase internally compatible with versa is sufficient.
 			statedb, err = state.New(current.Root(), database, nil)
 			if err == nil {
 				return statedb, noopReleaser, nil
@@ -121,7 +116,7 @@ func (eth *Ethereum) hashState(ctx context.Context, block *types.Block, reexec u
 				return nil, nil, fmt.Errorf("missing block %v %d", current.ParentHash(), current.NumberU64()-1)
 			}
 			current = parent
-			// TODO:: state.NewDatabase internally compatible with versa is sufficient.
+
 			statedb, err = state.New(current.Root(), database, nil)
 			if err == nil {
 				break
@@ -169,7 +164,6 @@ func (eth *Ethereum) hashState(ctx context.Context, block *types.Block, reexec u
 			return nil, nil, fmt.Errorf("stateAtBlock commit failed, number %d root %v: %w",
 				current.NumberU64(), current.Root().Hex(), err)
 		}
-		// TODO:: state.NewDatabase internally compatible with versa is sufficient.
 		statedb, err = state.New(root, database, nil) // nolint:staticcheck
 		if err != nil {
 			return nil, nil, fmt.Errorf("state reset after block %d failed: %v", current.NumberU64(), err)

eth/sync_test.go

@@ -112,14 +112,7 @@ func testChainSyncWithBlobs(t *testing.T, mode downloader.SyncMode, preCancunBlk
 	cancunTime := (preCancunBlks + 1) * 10
 	config.CancunTime = &cancunTime
 
-	// Create an empty handler
-	empty := newTestParliaHandlerAfterCancun(t, &config, mode, 0, 0)
-	defer empty.close()
-	if downloader.SnapSync == mode && !empty.handler.snapSync.Load() {
-		t.Fatalf("snap sync disabled on pristine blockchain")
-	}
-
-	// Create a full handler
+	// Create a full handler and ensure snap sync ends up disabled
 	full := newTestParliaHandlerAfterCancun(t, &config, mode, preCancunBlks, postCancunBlks)
 	defer full.close()
 	if downloader.SnapSync == mode && full.handler.snapSync.Load() {
@@ -129,6 +122,13 @@ func testChainSyncWithBlobs(t *testing.T, mode downloader.SyncMode, preCancunBlk
 	// check blocks and blobs
 	checkChainWithBlobs(t, full.chain, preCancunBlks, postCancunBlks)
 
+	// Create an empty handler and ensure it's in snap sync mode
+	empty := newTestParliaHandlerAfterCancun(t, &config, mode, 0, 0)
+	defer empty.close()
+	if downloader.SnapSync == mode && !empty.handler.snapSync.Load() {
+		t.Fatalf("snap sync disabled on pristine blockchain")
+	}
+
 	// Sync up the two handlers via both `eth` and `snap`
 	ethVer := uint(eth.ETH68)
 	snapVer := uint(snap.SNAP1)
@@ -151,6 +151,8 @@ func testChainSyncWithBlobs(t *testing.T, mode downloader.SyncMode, preCancunBlk
 	go full.handler.runEthPeer(fullPeerEth, func(peer *eth.Peer) error {
 		return eth.Handle((*ethHandler)(full.handler), peer)
 	})
+	// Wait a bit for the above handlers to start
+	time.Sleep(250 * time.Millisecond)
 
 	emptyPipeSnap, fullPipeSnap := p2p.MsgPipe()
 	defer emptyPipeSnap.Close()
@@ -165,17 +167,14 @@ func testChainSyncWithBlobs(t *testing.T, mode downloader.SyncMode, preCancunBlk
 	go full.handler.runSnapExtension(fullPeerSnap, func(peer *snap.Peer) error {
 		return snap.Handle((*snapHandler)(full.handler), peer)
 	})
+	// Wait a bit for the above handlers to start
+	time.Sleep(250 * time.Millisecond)
 
-	for empty.handler.peers.snapLen() < 1 {
-		// Wait a bit for the above handlers to start
-		time.Sleep(100 * time.Millisecond)
-	}
-
+	// Check that snap sync was disabled
 	op := peerToSyncOp(mode, empty.handler.peers.peerWithHighestTD())
 	if err := empty.handler.doSync(op); err != nil {
 		t.Fatal("sync failed:", err)
 	}
-	// Check that snap sync was disabled
 	if !empty.handler.synced.Load() {
 		t.Fatalf("full sync not done after successful synchronisation")
 	}

ethdb/database.go

@@ -180,6 +180,12 @@ type StateStoreReader interface {
 	StateStoreReader() Reader
 }
 
+type BlockStore interface {
+	BlockStore() Database
+	SetBlockStore(block Database)
+	HasSeparateBlockStore() bool
+}
+
 type BlockStoreReader interface {
 	BlockStoreReader() Reader
 }
@@ -188,14 +194,6 @@ type BlockStoreWriter interface {
 	BlockStoreWriter() Writer
 }
 
-// MultiDatabaseReader contains the methods required to read data from both key-value as well as
-// blockStore or stateStore.
-type MultiDatabaseReader interface {
-	KeyValueReader
-	StateStoreReader
-	BlockStoreReader
-}
-
 // Reader contains the methods required to read data from both key-value as well as
 // immutable ancient data.
 type Reader interface {
@@ -236,16 +234,8 @@ type DiffStore interface {
 type StateStore interface {
 	StateStore() Database
 	SetStateStore(state Database)
-	GetStateStore() Database
 }
 
-type BlockStore interface {
-	BlockStore() Database
-	SetBlockStore(block Database)
-	HasSeparateBlockStore() bool
-}
-
-// @TODO:: add VersaDB() method
 // Database contains all the methods required by the high level database to not
 // only access the key-value data store but also the chain freezer.
 type Database interface {

ethdb/memorydb/memorydb.go

@@ -39,9 +39,6 @@ var (
 	// errSnapshotReleased is returned if callers want to retrieve data from a
 	// released snapshot.
 	errSnapshotReleased = errors.New("snapshot released")
-
-	// errNotSupported is returned if the database doesn't support the required operation.
-	errNotSupported = errors.New("this operation is not supported")
 )
 
 // Database is an ephemeral key-value store. Apart from basic data storage
@@ -50,84 +47,6 @@ var (
 type Database struct {
 	db   map[string][]byte
 	lock sync.RWMutex
-
-	stateStore ethdb.Database
-	blockStore ethdb.Database
-}
-
-func (db *Database) ModifyAncients(f func(ethdb.AncientWriteOp) error) (int64, error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (db *Database) TruncateHead(n uint64) (uint64, error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (db *Database) TruncateTail(n uint64) (uint64, error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (db *Database) Sync() error {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (db *Database) TruncateTableTail(kind string, tail uint64) (uint64, error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (db *Database) ResetTable(kind string, startAt uint64, onlyEmpty bool) error {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (db *Database) HasAncient(kind string, number uint64) (bool, error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (db *Database) Ancient(kind string, number uint64) ([]byte, error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (db *Database) AncientRange(kind string, start, count, maxBytes uint64) ([][]byte, error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (db *Database) Ancients() (uint64, error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (db *Database) Tail() (uint64, error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (db *Database) AncientSize(kind string) (uint64, error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (db *Database) ItemAmountInAncient() (uint64, error) {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (db *Database) AncientOffSet() uint64 {
-	//TODO implement me
-	panic("implement me")
-}
-
-func (db *Database) ReadAncients(fn func(ethdb.AncientReaderOp) error) (err error) {
-	//TODO implement me
-	panic("implement me")
 }
 
 // New returns a wrapped map with all the required database interface methods
@@ -285,37 +204,6 @@ func (db *Database) Len() int {
 	return len(db.db)
 }
 
-func (db *Database) StateStoreReader() ethdb.Reader {
-	if db.stateStore == nil {
-		return db
-	}
-	return db.stateStore
-}
-
-func (db *Database) BlockStoreReader() ethdb.Reader {
-	if db.blockStore == nil {
-		return db
-	}
-	return db.blockStore
-}
-
-func (db *Database) BlockStoreWriter() ethdb.Writer {
-	if db.blockStore == nil {
-		return db
-	}
-	return db.blockStore
-}
-
-// convertLegacyFn takes a raw freezer entry in an older format and
-// returns it in the new format.
-type convertLegacyFn = func([]byte) ([]byte, error)
-
-// MigrateTable processes the entries in a given table in sequence
-// converting them to a new format if they're of an old format.
-func (db *Database) MigrateTable(kind string, convert convertLegacyFn) error {
-	return errNotSupported
-}
-
 // keyvalue is a key-value tuple tagged with a deletion field to allow creating
 // memory-database write batches.
 type keyvalue struct {

ethdb/remotedb/remotedb.go

@@ -122,10 +122,6 @@ func (db *Database) SetStateStore(state ethdb.Database) {
 	panic("not supported")
 }
 
-func (db *Database) GetStateStore() ethdb.Database {
-	panic("not supported")
-}
-
 func (db *Database) StateStoreReader() ethdb.Reader {
 	return db
 }

go.mod

@@ -2,6 +2,8 @@ module github.com/ethereum/go-ethereum
 
 go 1.21
 
+toolchain go1.21.5
+
 require (
 	github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.2.0
 	github.com/Microsoft/go-winio v0.6.1
@@ -15,8 +17,8 @@ require (
 	github.com/btcsuite/btcd/btcec/v2 v2.3.2
 	github.com/cespare/cp v1.1.1
 	github.com/cloudflare/cloudflare-go v0.79.0
-	github.com/cockroachdb/pebble v1.1.0
 	github.com/cometbft/cometbft v0.37.0
+	github.com/cockroachdb/pebble v1.1.0
 	github.com/consensys/gnark-crypto v0.12.1
 	github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233
 	github.com/crate-crypto/go-kzg-4844 v0.7.0
@@ -24,7 +26,7 @@ require (
 	github.com/deckarep/golang-set/v2 v2.5.0
 	github.com/dop251/goja v0.0.0-20230806174421-c933cf95e127
 	github.com/ethereum/c-kzg-4844 v0.4.0
-	github.com/fatih/color v1.16.0
+	github.com/fatih/color v1.13.0
 	github.com/fatih/structs v1.1.0
 	github.com/fjl/gencodec v0.0.0-20230517082657-f9840df7b83e
 	github.com/fjl/memsize v0.0.2
@@ -37,7 +39,7 @@ require (
 	github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb
 	github.com/google/gofuzz v1.2.0
 	github.com/google/pprof v0.0.0-20240207164012-fb44976bdcd5
-	github.com/google/uuid v1.5.0
+	github.com/google/uuid v1.4.0
 	github.com/gorilla/websocket v1.5.1
 	github.com/graph-gophers/graphql-go v1.3.0
 	github.com/hashicorp/go-bexpr v0.1.10
@@ -82,7 +84,7 @@ require (
 	golang.org/x/crypto v0.21.0
 	golang.org/x/exp v0.0.0-20240213143201-ec583247a57a
 	golang.org/x/sync v0.6.0
-	golang.org/x/sys v0.20.0
+	golang.org/x/sys v0.18.0
 	golang.org/x/text v0.14.0
 	golang.org/x/time v0.5.0
 	golang.org/x/tools v0.18.0
@@ -96,7 +98,6 @@ require (
 	github.com/Azure/azure-sdk-for-go/sdk/internal v1.3.0 // indirect
 	github.com/BurntSushi/toml v1.3.2 // indirect
 	github.com/DataDog/zstd v1.5.5 // indirect
-	github.com/allegro/bigcache v1.2.1 // indirect
 	github.com/aristanetworks/goarista v0.0.0-20200805130819-fd197cf57d96 // indirect
 	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.13.13 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.43 // indirect
@@ -159,7 +160,7 @@ require (
 	github.com/grpc-ecosystem/grpc-gateway/v2 v2.0.1 // indirect
 	github.com/gtank/merlin v0.1.1 // indirect
 	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
-	github.com/hashicorp/go-retryablehttp v0.7.7 // indirect
+	github.com/hashicorp/go-retryablehttp v0.7.4 // indirect
 	github.com/hashicorp/golang-lru/v2 v2.0.5 // indirect
 	github.com/herumi/bls-eth-go-binary v0.0.0-20210917013441-d37c07cfda4e // indirect
 	github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097 // indirect
@@ -232,10 +233,12 @@ require (
 	github.com/prometheus/common v0.47.0 // indirect
 	github.com/prometheus/procfs v0.12.0 // indirect
 	github.com/prometheus/prom2json v1.3.0 // indirect
+	github.com/prysmaticlabs/eth2-types v0.0.0-20210303084904-c9735a06829d // indirect
 	github.com/prysmaticlabs/fastssz v0.0.0-20221107182844-78142813af44 // indirect
 	github.com/prysmaticlabs/go-bitfield v0.0.0-20210809151128-385d8c5e3fb7 // indirect
 	github.com/prysmaticlabs/gohashtree v0.0.4-beta // indirect
 	github.com/prysmaticlabs/prombbolt v0.0.0-20210126082820-9b7adba6db7c // indirect
+	github.com/prysmaticlabs/prysm v0.0.0-20220124113610-e26cde5e091b // indirect
 	github.com/quic-go/qpack v0.4.0 // indirect
 	github.com/quic-go/quic-go v0.42.0 // indirect
 	github.com/quic-go/webtransport-go v0.6.0 // indirect
@@ -246,10 +249,9 @@ require (
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/sasha-s/go-deadlock v0.3.1 // indirect
 	github.com/schollz/progressbar/v3 v3.3.4 // indirect
-	github.com/sirupsen/logrus v1.9.3 // indirect
+	github.com/sirupsen/logrus v1.9.0 // indirect
 	github.com/spaolacci/murmur3 v1.1.0 // indirect
 	github.com/spf13/afero v1.10.0 // indirect
-	github.com/tecbot/gorocksdb v0.0.0-20191217155057-f0fad39f321c // indirect
 	github.com/thomaso-mirodin/intmath v0.0.0-20160323211736-5dc6d854e46e // indirect
 	github.com/tidwall/gjson v1.10.2 // indirect
 	github.com/tidwall/match v1.1.1 // indirect
@@ -264,7 +266,7 @@ require (
 	github.com/wealdtech/go-eth2-util v1.6.3 // indirect
 	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
 	github.com/yusufpapurcu/wmi v1.2.3 // indirect
-	go.etcd.io/bbolt v1.3.9 // indirect
+	go.etcd.io/bbolt v1.3.7 // indirect
 	go.opencensus.io v0.24.0 // indirect
 	go.uber.org/dig v1.17.1 // indirect
 	go.uber.org/fx v1.20.1 // indirect
@@ -277,10 +279,8 @@ require (
 	golang.org/x/term v0.18.0 // indirect
 	google.golang.org/api v0.44.0 // indirect
 	google.golang.org/appengine v1.6.7 // indirect
-	google.golang.org/genproto v0.0.0-20231016165738-49dd2c1f3d0b // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20231012201019-e917dd12ba7a // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20231016165738-49dd2c1f3d0b // indirect
-	google.golang.org/grpc v1.59.0 // indirect
+	google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1 // indirect
+	google.golang.org/grpc v1.56.3 // indirect
 	google.golang.org/protobuf v1.33.0 // indirect
 	gopkg.in/inf.v0 v0.9.1 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
@@ -295,7 +295,8 @@ require (
 )
 
 replace (
-	github.com/cometbft/cometbft => github.com/bnb-chain/greenfield-cometbft v1.3.1
+	github.com/btcsuite/btcd => github.com/btcsuite/btcd v0.23.0
+	github.com/cometbft/cometbft => github.com/bnb-chain/greenfield-tendermint v0.0.0-20230417032003-4cda1f296fb2
 	github.com/grpc-ecosystem/grpc-gateway/v2 => github.com/prysmaticlabs/grpc-gateway/v2 v2.3.1-0.20210702154020-550e1cd83ec1
 	github.com/syndtr/goleveldb v1.0.1 => github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7
 	github.com/tendermint/tendermint => github.com/bnb-chain/tendermint v0.31.16

internal/ethapi/dbapi.go

@@ -33,11 +33,11 @@ func (api *DebugAPI) DbGet(key string) (hexutil.Bytes, error) {
 // DbAncient retrieves an ancient binary blob from the append-only immutable files.
 // It is a mapping to the `AncientReaderOp.Ancient` method
 func (api *DebugAPI) DbAncient(kind string, number uint64) (hexutil.Bytes, error) {
-	return api.b.ChainDb().BlockStore().Ancient(kind, number)
+	return api.b.ChainDb().Ancient(kind, number)
 }
 
 // DbAncients returns the ancient item numbers in the ancient store.
 // It is a mapping to the `AncientReaderOp.Ancients` method
 func (api *DebugAPI) DbAncients() (uint64, error) {
-	return api.b.ChainDb().BlockStore().Ancients()
+	return api.b.ChainDb().Ancients()
 }

miner/bid_simulator.go

@@ -7,7 +7,6 @@ import (
 	"math/big"
 	"net"
 	"net/http"
-	"strconv"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -69,12 +68,6 @@ type simBidReq struct {
 	interruptCh chan int32
 }
 
-// newBidPackage is the warp of a new bid and a feedback channel
-type newBidPackage struct {
-	bid      *types.Bid
-	feedback chan error
-}
-
 // bidSimulator is in charge of receiving bid from builders, reporting issue to builders.
 // And take care of bid simulation, rewards computing, best bid maintaining.
 type bidSimulator struct {
@@ -102,7 +95,7 @@ type bidSimulator struct {
 
 	// channels
 	simBidCh chan *simBidReq
-	newBidCh chan newBidPackage
+	newBidCh chan *types.Bid
 
 	pendingMu sync.RWMutex
 	pending   map[uint64]map[common.Address]map[common.Hash]struct{} // blockNumber -> builder -> bidHash -> struct{}
@@ -135,7 +128,7 @@ func newBidSimulator(
 		chainHeadCh:   make(chan core.ChainHeadEvent, chainHeadChanSize),
 		builders:      make(map[common.Address]*builderclient.Client),
 		simBidCh:      make(chan *simBidReq),
-		newBidCh:      make(chan newBidPackage, 100),
+		newBidCh:      make(chan *types.Bid, 100),
 		pending:       make(map[uint64]map[common.Address]map[common.Hash]struct{}),
 		bestBid:       make(map[common.Hash]*BidRuntime),
 		simulatingBid: make(map[common.Hash]*BidRuntime),
@@ -334,10 +327,6 @@ func (b *bidSimulator) newBidLoop() {
 		}
 	}
 
-	genDiscardedReply := func(betterBid *BidRuntime) error {
-		return fmt.Errorf("bid is discarded, current bestBid is [blockReward: %s, validatorReward: %s]", betterBid.expectedBlockReward, betterBid.expectedValidatorReward)
-	}
-
 	for {
 		select {
 		case newBid := <-b.newBidCh:
@@ -345,47 +334,60 @@ func (b *bidSimulator) newBidLoop() {
 				continue
 			}
 
-			bidRuntime, err := newBidRuntime(newBid.bid, b.config.ValidatorCommission)
-			if err != nil {
-				if newBid.feedback != nil {
-					newBid.feedback <- err
-				}
+			// check the block reward and validator reward of the newBid
+			expectedBlockReward := newBid.GasFee
+			expectedValidatorReward := new(big.Int).Mul(expectedBlockReward, big.NewInt(int64(b.config.ValidatorCommission)))
+			expectedValidatorReward.Div(expectedValidatorReward, big.NewInt(10000))
+			expectedValidatorReward.Sub(expectedValidatorReward, newBid.BuilderFee)
+
+			if expectedValidatorReward.Cmp(big.NewInt(0)) < 0 {
+				// damage self profit, ignore
+				log.Debug("BidSimulator: invalid bid, validator reward is less than 0, ignore",
+					"builder", newBid.Builder, "bidHash", newBid.Hash().Hex())
 				continue
 			}
 
-			var replyErr error
-			// simulatingBid will be nil if there is no bid in simulation, compare with the bestBid instead
-			if simulatingBid := b.GetSimulatingBid(newBid.bid.ParentHash); simulatingBid != nil {
-				// simulatingBid always better than bestBid, so only compare with simulatingBid if a simulatingBid exists
-				if bidRuntime.isExpectedBetterThan(simulatingBid) {
-					commit(commitInterruptBetterBid, bidRuntime)
-				} else {
-					replyErr = genDiscardedReply(simulatingBid)
-				}
-			} else {
-				// bestBid is nil means the bid is the first bid, otherwise the bid should compare with the bestBid
-				if bestBid := b.GetBestBid(newBid.bid.ParentHash); bestBid == nil ||
-					bidRuntime.isExpectedBetterThan(bestBid) {
-					commit(commitInterruptBetterBid, bidRuntime)
-				} else {
-					replyErr = genDiscardedReply(bestBid)
-				}
+			bidRuntime := &BidRuntime{
+				bid:                     newBid,
+				expectedBlockReward:     expectedBlockReward,
+				expectedValidatorReward: expectedValidatorReward,
+				packedBlockReward:       big.NewInt(0),
+				packedValidatorReward:   big.NewInt(0),
+				finished:                make(chan struct{}),
 			}
 
-			if newBid.feedback != nil {
-				newBid.feedback <- replyErr
+			simulatingBid := b.GetSimulatingBid(newBid.ParentHash)
+			// simulatingBid is nil means there is no bid in simulation
+			if simulatingBid == nil {
+				// bestBid is nil means bid is the first bid
+				bestBid := b.GetBestBid(newBid.ParentHash)
+				if bestBid == nil {
+					commit(commitInterruptBetterBid, bidRuntime)
+					continue
+				}
 
-				log.Info("[BID ARRIVED]",
-					"block", newBid.bid.BlockNumber,
-					"builder", newBid.bid.Builder,
-					"accepted", replyErr == nil,
-					"blockReward", weiToEtherStringF6(bidRuntime.expectedBlockReward),
-					"validatorReward", weiToEtherStringF6(bidRuntime.expectedValidatorReward),
-					"tx", len(newBid.bid.Txs),
-					"hash", newBid.bid.Hash().TerminalString(),
-				)
+				// if bestBid is not nil, check if newBid is better than bestBid
+				if bidRuntime.expectedBlockReward.Cmp(bestBid.expectedBlockReward) >= 0 &&
+					bidRuntime.expectedValidatorReward.Cmp(bestBid.expectedValidatorReward) >= 0 {
+					// if both reward are better than last simulating newBid, commit for simulation
+					commit(commitInterruptBetterBid, bidRuntime)
+					continue
+				}
+
+				log.Debug("BidSimulator: lower reward, ignore",
+					"builder", bidRuntime.bid.Builder, "bidHash", newBid.Hash().Hex())
+				continue
 			}
 
+			// simulatingBid must be better than bestBid, if newBid is better than simulatingBid, commit for simulation
+			if bidRuntime.expectedBlockReward.Cmp(simulatingBid.expectedBlockReward) >= 0 &&
+				bidRuntime.expectedValidatorReward.Cmp(simulatingBid.expectedValidatorReward) >= 0 {
+				// if both reward are better than last simulating newBid, commit for simulation
+				commit(commitInterruptBetterBid, bidRuntime)
+				continue
+			}
+
+			log.Debug("BidSimulator: lower reward, ignore", "builder", newBid.Builder, "bidHash", newBid.Hash().Hex())
 		case <-b.exitCh:
 			return
 		}
@@ -417,6 +419,10 @@ func (b *bidSimulator) clearLoop() {
 		b.bestBidMu.Unlock()
 
 		b.simBidMu.Lock()
+		if bid, ok := b.simulatingBid[parentHash]; ok {
+			bid.env.discard()
+		}
+		delete(b.simulatingBid, parentHash)
 		for k, v := range b.simulatingBid {
 			if v.bid.BlockNumber <= blockNumber-core.TriesInMemory {
 				v.env.discard()
@@ -440,19 +446,10 @@ func (b *bidSimulator) clearLoop() {
 func (b *bidSimulator) sendBid(_ context.Context, bid *types.Bid) error {
 	timer := time.NewTimer(1 * time.Second)
 	defer timer.Stop()
-
-	replyCh := make(chan error, 1)
-
 	select {
-	case b.newBidCh <- newBidPackage{bid: bid, feedback: replyCh}:
+	case b.newBidCh <- bid:
 		b.AddPending(bid.BlockNumber, bid.Builder, bid.Hash())
-	case <-timer.C:
-		return types.ErrMevBusy
-	}
-
-	select {
-	case reply := <-replyCh:
-		return reply
+		return nil
 	case <-timer.C:
 		return types.ErrMevBusy
 	}
@@ -498,8 +495,6 @@ func (b *bidSimulator) simBid(interruptCh chan int32, bidRuntime *BidRuntime) {
 	}
 
 	var (
-		startTS = time.Now()
-
 		blockNumber = bidRuntime.bid.BlockNumber
 		parentHash  = bidRuntime.bid.ParentHash
 		builder     = bidRuntime.bid.Builder
@@ -551,12 +546,12 @@ func (b *bidSimulator) simBid(interruptCh chan int32, bidRuntime *BidRuntime) {
 			}
 
 			select {
-			case b.newBidCh <- newBidPackage{bid: bidRuntime.bid}:
+			case b.newBidCh <- bidRuntime.bid:
 				log.Debug("BidSimulator: recommit", "builder", bidRuntime.bid.Builder, "bidHash", bidRuntime.bid.Hash().Hex())
 			default:
 			}
 		}
-	}(startTS)
+	}(time.Now())
 
 	// prepareWork will configure header with a suitable time according to consensus
 	// prepareWork will start trie prefetching
@@ -642,7 +637,7 @@ func (b *bidSimulator) simBid(interruptCh chan int32, bidRuntime *BidRuntime) {
 	if b.config.GreedyMergeTx {
 		delay := b.engine.Delay(b.chain, bidRuntime.env.header, &b.delayLeftOver)
 		if delay != nil && *delay > 0 {
-			bidTxsSet := mapset.NewThreadUnsafeSetWithSize[common.Hash](len(bidRuntime.bid.Txs))
+			bidTxsSet := mapset.NewSet[common.Hash]()
 			for _, tx := range bidRuntime.bid.Txs {
 				bidTxsSet.Add(tx.Hash())
 			}
@@ -667,30 +662,13 @@ func (b *bidSimulator) simBid(interruptCh chan int32, bidRuntime *BidRuntime) {
 	}
 
 	bestBid := b.GetBestBid(parentHash)
+
 	if bestBid == nil {
-		log.Info("[BID RESULT]", "win", "true[first]", "builder", bidRuntime.bid.Builder, "hash", bidRuntime.bid.Hash().TerminalString())
 		b.SetBestBid(bidRuntime.bid.ParentHash, bidRuntime)
 		success = true
 		return
 	}
 
-	if bidRuntime.bid.Hash() != bestBid.bid.Hash() {
-		log.Info("[BID RESULT]",
-			"win", bidRuntime.packedBlockReward.Cmp(bestBid.packedBlockReward) >= 0,
-
-			"bidHash", bidRuntime.bid.Hash().TerminalString(),
-			"bestHash", bestBid.bid.Hash().TerminalString(),
-
-			"bidGasFee", weiToEtherStringF6(bidRuntime.packedBlockReward),
-			"bestGasFee", weiToEtherStringF6(bestBid.packedBlockReward),
-
-			"bidBlockTx", bidRuntime.env.tcount,
-			"bestBlockTx", bestBid.env.tcount,
-
-			"simElapsed", time.Since(startTS),
-		)
-	}
-
 	// this is the simplest strategy: best for all the delegators.
 	if bidRuntime.packedBlockReward.Cmp(bestBid.packedBlockReward) >= 0 {
 		b.SetBestBid(bidRuntime.bid.ParentHash, bidRuntime)
@@ -704,7 +682,7 @@ func (b *bidSimulator) simBid(interruptCh chan int32, bidRuntime *BidRuntime) {
 	}
 
 	select {
-	case b.newBidCh <- newBidPackage{bid: bestBid.bid}:
+	case b.newBidCh <- bestBid.bid:
 		log.Debug("BidSimulator: recommit last bid", "builder", bidRuntime.bid.Builder, "bidHash", bidRuntime.bid.Hash().Hex())
 	default:
 	}
@@ -724,7 +702,7 @@ func (b *bidSimulator) reportIssue(bidRuntime *BidRuntime, err error) {
 		})
 
 		if err != nil {
-			log.Warn("BidSimulator: failed to report issue", "builder", bidRuntime.bid.Builder, "err", err)
+			log.Error("BidSimulator: failed to report issue", "builder", bidRuntime.bid.Builder, "err", err)
 		}
 	}
 }
@@ -744,42 +722,11 @@ type BidRuntime struct {
 	duration time.Duration
 }
 
-func newBidRuntime(newBid *types.Bid, validatorCommission uint64) (*BidRuntime, error) {
-	// check the block reward and validator reward of the newBid
-	expectedBlockReward := newBid.GasFee
-	expectedValidatorReward := new(big.Int).Mul(expectedBlockReward, big.NewInt(int64(validatorCommission)))
-	expectedValidatorReward.Div(expectedValidatorReward, big.NewInt(10000))
-	expectedValidatorReward.Sub(expectedValidatorReward, newBid.BuilderFee)
-
-	if expectedValidatorReward.Cmp(big.NewInt(0)) < 0 {
-		// damage self profit, ignore
-		log.Debug("BidSimulator: invalid bid, validator reward is less than 0, ignore",
-			"builder", newBid.Builder, "bidHash", newBid.Hash().Hex())
-		return nil, fmt.Errorf("validator reward is less than 0, value: %s, commissionConfig: %d", expectedValidatorReward, validatorCommission)
-	}
-
-	bidRuntime := &BidRuntime{
-		bid:                     newBid,
-		expectedBlockReward:     expectedBlockReward,
-		expectedValidatorReward: expectedValidatorReward,
-		packedBlockReward:       big.NewInt(0),
-		packedValidatorReward:   big.NewInt(0),
-		finished:                make(chan struct{}),
-	}
-
-	return bidRuntime, nil
-}
-
 func (r *BidRuntime) validReward() bool {
 	return r.packedBlockReward.Cmp(r.expectedBlockReward) >= 0 &&
 		r.packedValidatorReward.Cmp(r.expectedValidatorReward) >= 0
 }
 
-func (r *BidRuntime) isExpectedBetterThan(other *BidRuntime) bool {
-	return r.expectedBlockReward.Cmp(other.expectedBlockReward) >= 0 &&
-		r.expectedValidatorReward.Cmp(other.expectedValidatorReward) >= 0
-}
-
 // packReward calculates packedBlockReward and packedValidatorReward
 func (r *BidRuntime) packReward(validatorCommission uint64) {
 	r.packedBlockReward = r.env.state.GetBalance(consensus.SystemAddress).ToBig()
@@ -835,8 +782,3 @@ func (r *BidRuntime) commitTransaction(chain *core.BlockChain, chainConfig *para
 
 	return nil
 }
-
-func weiToEtherStringF6(wei *big.Int) string {
-	f, _ := new(big.Float).Quo(new(big.Float).SetInt(wei), big.NewFloat(params.Ether)).Float64()
-	return strconv.FormatFloat(f, 'f', 6, 64)
-}

miner/worker.go

@@ -1371,13 +1371,7 @@ LOOP:
 				bestWork = bestBid.env
 				from = bestBid.bid.Builder
 
-				log.Info("[BUILDER BLOCK]",
-					"block", bestWork.header.Number.Uint64(),
-					"builder", from,
-					"blockReward", weiToEtherStringF6(bestBid.packedBlockReward),
-					"validatorReward", weiToEtherStringF6(bestBid.packedValidatorReward),
-					"bid", bestBid.bid.Hash().TerminalString(),
-				)
+				log.Debug("BidSimulator: bid win", "block", bestWork.header.Number.Uint64(), "bid", bestBid.bid.Hash())
 			}
 		}
 	}

node/node.go

@@ -74,11 +74,11 @@ const (
 	initializingState = iota
 	runningState
 	closedState
-	blockDbCacheSize           = 256
-	blockDbHandlesMinSize      = 1000
-	blockDbHandlesMaxSize      = 2000
-	chainDbMemoryPercentage    = 50
-	chainDbHandlesPercentage   = 50
+	blockDbCacheSize        = 256
+	blockDbHandlesMinSize   = 1000
+	blockDbHandlesMaxSize   = 2000
+	chainDbMemoryPercentage = 50
+	chainDbHandlesPercentage
 	diffStoreHandlesPercentage = 20
 )
 
@@ -791,15 +791,14 @@ func (n *Node) OpenDatabase(name string, cache, handles int, namespace string, r
 
 func (n *Node) OpenAndMergeDatabase(name string, namespace string, readonly bool, config *ethconfig.Config) (ethdb.Database, error) {
 	var (
-		err                          error
-		stateDiskDb                  ethdb.Database
-		blockDb                      ethdb.Database
-		disableChainDbFreeze         = false
-		blockDbHandlesSize           int
-		diffStoreHandles             int
-		chainDataHandles             = config.DatabaseHandles
-		chainDbCache                 = config.DatabaseCache
-		stateDbCache, stateDbHandles int
+		err                  error
+		stateDiskDb          ethdb.Database
+		blockDb              ethdb.Database
+		disableChainDbFreeze = false
+		blockDbHandlesSize   int
+		diffStoreHandles     int
+		chainDataHandles     = config.DatabaseHandles
+		chainDbCache         = config.DatabaseCache
 	)
 
 	if config.PersistDiff {
@@ -819,17 +818,10 @@ func (n *Node) OpenAndMergeDatabase(name string, namespace string, readonly bool
 		} else {
 			blockDbHandlesSize = blockDbHandlesMinSize
 		}
-		stateDbCache = config.DatabaseCache - chainDbCache - blockDbCacheSize
-		stateDbHandles = config.DatabaseHandles - chainDataHandles - blockDbHandlesSize
+		stateDbCache := config.DatabaseCache - chainDbCache - blockDbCacheSize
+		stateDbHandles := config.DatabaseHandles - chainDataHandles - blockDbHandlesSize
 		disableChainDbFreeze = true
-	}
 
-	chainDB, err := n.OpenDatabaseWithFreezer(name, chainDbCache, chainDataHandles, config.DatabaseFreezer, namespace, readonly, disableChainDbFreeze, false, config.PruneAncientData)
-	if err != nil {
-		return nil, err
-	}
-
-	if isMultiDatabase {
 		// Allocate half of the  handles and chainDbCache to this separate state data database
 		stateDiskDb, err = n.OpenDatabaseWithFreezer(name+"/state", stateDbCache, stateDbHandles, "", "eth/db/statedata/", readonly, true, false, config.PruneAncientData)
 		if err != nil {
@@ -841,6 +833,14 @@ func (n *Node) OpenAndMergeDatabase(name string, namespace string, readonly bool
 			return nil, err
 		}
 		log.Warn("Multi-database is an experimental feature")
+	}
+
+	chainDB, err := n.OpenDatabaseWithFreezer(name, chainDbCache, chainDataHandles, config.DatabaseFreezer, namespace, readonly, disableChainDbFreeze, false, config.PruneAncientData)
+	if err != nil {
+		return nil, err
+	}
+
+	if isMultiDatabase {
 		chainDB.SetStateStore(stateDiskDb)
 		chainDB.SetBlockStore(blockDb)
 	}

params/config.go

@@ -153,7 +153,6 @@ var (
 		FeynmanFixTime:      newUint64(1713419340), // 2024-04-18 05:49:00 AM UTC
 		CancunTime:          newUint64(1718863500), // 2024-06-20 06:05:00 AM UTC
 		HaberTime:           newUint64(1718863500), // 2024-06-20 06:05:00 AM UTC
-		HaberFixTime:        nil,                   // TBD
 		BohrTime:            nil,
 
 		Parlia: &ParliaConfig{
@@ -194,7 +193,6 @@ var (
 		FeynmanFixTime:      newUint64(1711342800), // 2024-03-25 5:00:00 AM UTC
 		CancunTime:          newUint64(1713330442), // 2024-04-17 05:07:22 AM UTC
 		HaberTime:           newUint64(1716962820), // 2024-05-29 06:07:00 AM UTC
-		HaberFixTime:        newUint64(1719986788), // 2024-07-03 06:06:28 AM UTC
 		BohrTime:            nil,
 
 		Parlia: &ParliaConfig{
@@ -236,12 +234,12 @@ var (
 		FeynmanFixTime:      newUint64(0),
 		CancunTime:          newUint64(0),
 		HaberTime:           newUint64(0),
-		HaberFixTime:        newUint64(0),
-		BohrTime:            newUint64(0),
+		HaberFixTime:        _rialto_upgrade_height_,
+		BohrTime:            _rialto_upgrade_height_,
 
 		Parlia: &ParliaConfig{
-			Period: 3,
-			Epoch:  200,
+			Period: _rialto_parlia_period_,
+			Epoch:  _rialto_parlia_period_,
 		},
 	}
 
@@ -1196,9 +1194,6 @@ func (c *ChainConfig) checkCompatible(newcfg *ChainConfig, headNumber *big.Int,
 	if isForkTimestampIncompatible(c.HaberFixTime, newcfg.HaberFixTime, headTimestamp) {
 		return newTimestampCompatError("HaberFix fork timestamp", c.HaberFixTime, newcfg.HaberFixTime)
 	}
-	if isForkTimestampIncompatible(c.BohrTime, newcfg.BohrTime, headTimestamp) {
-		return newTimestampCompatError("Bohr fork timestamp", c.BohrTime, newcfg.BohrTime)
-	}
 	if isForkTimestampIncompatible(c.PragueTime, newcfg.PragueTime, headTimestamp) {
 		return newTimestampCompatError("Prague fork timestamp", c.PragueTime, newcfg.PragueTime)
 	}

params/version.go

@@ -23,7 +23,7 @@ import (
 const (
 	VersionMajor = 1  // Major version component of the current release
 	VersionMinor = 4  // Minor version component of the current release
-	VersionPatch = 12 // Patch version component of the current release
+	VersionPatch = 10 // Patch version component of the current release
 	VersionMeta  = "" // Version metadata to append to the version string
 )
 

signer/fourbyte/abi.go

@@ -98,7 +98,7 @@ func parseCallData(calldata []byte, unescapedAbidata string) (*decodedCallData,
 	if len(argdata)%32 != 0 {
 		return nil, fmt.Errorf("invalid call data; length should be a multiple of 32 bytes (was %d)", len(argdata))
 	}
-	// Validate the called method and unpack the call data accordingly
+	// Validate the called method and upack the call data accordingly
 	abispec, err := abi.JSON(strings.NewReader(unescapedAbidata))
 	if err != nil {
 		return nil, fmt.Errorf("invalid method signature (%q): %v", unescapedAbidata, err)

trie/sync.go

@@ -229,7 +229,7 @@ func (batch *syncMemBatch) delNode(owner common.Hash, path []byte) {
 // and reconstructs the trie step by step until all is done.
 type Sync struct {
 	scheme   string                       // Node scheme descriptor used in database.
-	database ethdb.Database               // Persistent database to check for existing entries
+	database ethdb.KeyValueReader         // Persistent database to check for existing entries
 	membatch *syncMemBatch                // Memory buffer to avoid frequent database writes
 	nodeReqs map[string]*nodeRequest      // Pending requests pertaining to a trie node path
 	codeReqs map[common.Hash]*codeRequest // Pending requests pertaining to a code hash
@@ -238,7 +238,7 @@ type Sync struct {
 }
 
 // NewSync creates a new trie data download scheduler.
-func NewSync(root common.Hash, database ethdb.Database, callback LeafCallback, scheme string) *Sync {
+func NewSync(root common.Hash, database ethdb.KeyValueReader, callback LeafCallback, scheme string) *Sync {
 	ts := &Sync{
 		scheme:   scheme,
 		database: database,
@@ -420,7 +420,7 @@ func (s *Sync) ProcessNode(result NodeSyncResult) error {
 // Commit flushes the data stored in the internal membatch out to persistent
 // storage, returning any occurred error. The whole data set will be flushed
 // in an atomic database batch.
-func (s *Sync) Commit(dbw ethdb.Batch, stateBatch ethdb.Batch) error {
+func (s *Sync) Commit(dbw ethdb.Batch) error {
 	// Flush the pending node writes into database batch.
 	var (
 		account int
@@ -430,17 +430,9 @@ func (s *Sync) Commit(dbw ethdb.Batch, stateBatch ethdb.Batch) error {
 		if op.isDelete() {
 			// node deletion is only supported in path mode.
 			if op.owner == (common.Hash{}) {
-				if stateBatch != nil {
-					rawdb.DeleteAccountTrieNode(stateBatch, op.path)
-				} else {
-					rawdb.DeleteAccountTrieNode(dbw, op.path)
-				}
+				rawdb.DeleteAccountTrieNode(dbw, op.path)
 			} else {
-				if stateBatch != nil {
-					rawdb.DeleteStorageTrieNode(stateBatch, op.owner, op.path)
-				} else {
-					rawdb.DeleteStorageTrieNode(dbw, op.owner, op.path)
-				}
+				rawdb.DeleteStorageTrieNode(dbw, op.owner, op.path)
 			}
 			deletionGauge.Inc(1)
 		} else {
@@ -449,11 +441,7 @@ func (s *Sync) Commit(dbw ethdb.Batch, stateBatch ethdb.Batch) error {
 			} else {
 				storage += 1
 			}
-			if stateBatch != nil {
-				rawdb.WriteTrieNode(stateBatch, op.owner, op.path, op.hash, op.blob, s.scheme)
-			} else {
-				rawdb.WriteTrieNode(dbw, op.owner, op.path, op.hash, op.blob, s.scheme)
-			}
+			rawdb.WriteTrieNode(dbw, op.owner, op.path, op.hash, op.blob, s.scheme)
 		}
 	}
 	accountNodeSyncedGauge.Inc(int64(account))
@@ -558,9 +546,9 @@ func (s *Sync) children(req *nodeRequest, object node) ([]*nodeRequest, error) {
 				// the performance impact negligible.
 				var exists bool
 				if owner == (common.Hash{}) {
-					exists = rawdb.ExistsAccountTrieNode(s.database.StateStoreReader(), append(inner, key[:i]...))
+					exists = rawdb.ExistsAccountTrieNode(s.database, append(inner, key[:i]...))
 				} else {
-					exists = rawdb.ExistsStorageTrieNode(s.database.StateStoreReader(), owner, append(inner, key[:i]...))
+					exists = rawdb.ExistsStorageTrieNode(s.database, owner, append(inner, key[:i]...))
 				}
 				if exists {
 					s.membatch.delNode(owner, append(inner, key[:i]...))
@@ -699,15 +687,15 @@ func (s *Sync) commitCodeRequest(req *codeRequest) error {
 func (s *Sync) hasNode(owner common.Hash, path []byte, hash common.Hash) (exists bool, inconsistent bool) {
 	// If node is running with hash scheme, check the presence with node hash.
 	if s.scheme == rawdb.HashScheme {
-		return rawdb.HasLegacyTrieNode(s.database.StateStoreReader(), hash), false
+		return rawdb.HasLegacyTrieNode(s.database, hash), false
 	}
 	// If node is running with path scheme, check the presence with node path.
 	var blob []byte
 	var dbHash common.Hash
 	if owner == (common.Hash{}) {
-		blob, dbHash = rawdb.ReadAccountTrieNode(s.database.StateStoreReader(), path)
+		blob, dbHash = rawdb.ReadAccountTrieNode(s.database, path)
 	} else {
-		blob, dbHash = rawdb.ReadStorageTrieNode(s.database.StateStoreReader(), owner, path)
+		blob, dbHash = rawdb.ReadStorageTrieNode(s.database, owner, path)
 	}
 	exists = hash == dbHash
 	inconsistent = !exists && len(blob) != 0

trie/sync_test.go

@@ -27,6 +27,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/ethdb/memorydb"
 	"github.com/ethereum/go-ethereum/trie/trienode"
 )
 
@@ -142,7 +143,7 @@ func TestEmptySync(t *testing.T) {
 	emptyD, _ := New(TrieID(types.EmptyRootHash), dbD)
 
 	for i, trie := range []*Trie{emptyA, emptyB, emptyC, emptyD} {
-		sync := NewSync(trie.Hash(), rawdb.NewMemoryDatabase(), nil, []*testDb{dbA, dbB, dbC, dbD}[i].Scheme())
+		sync := NewSync(trie.Hash(), memorydb.New(), nil, []*testDb{dbA, dbB, dbC, dbD}[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)
 		}
@@ -211,7 +212,7 @@ func testIterativeSync(t *testing.T, count int, bypath bool, scheme string) {
 			}
 		}
 		batch := diskdb.NewBatch()
-		if err := sched.Commit(batch, nil); err != nil {
+		if err := sched.Commit(batch); err != nil {
 			t.Fatalf("failed to commit data: %v", err)
 		}
 		batch.Write()
@@ -277,7 +278,7 @@ func testIterativeDelayedSync(t *testing.T, scheme string) {
 			}
 		}
 		batch := diskdb.NewBatch()
-		if err := sched.Commit(batch, nil); err != nil {
+		if err := sched.Commit(batch); err != nil {
 			t.Fatalf("failed to commit data: %v", err)
 		}
 		batch.Write()
@@ -347,7 +348,7 @@ func testIterativeRandomSync(t *testing.T, count int, scheme string) {
 			}
 		}
 		batch := diskdb.NewBatch()
-		if err := sched.Commit(batch, nil); err != nil {
+		if err := sched.Commit(batch); err != nil {
 			t.Fatalf("failed to commit data: %v", err)
 		}
 		batch.Write()
@@ -418,7 +419,7 @@ func testIterativeRandomDelayedSync(t *testing.T, scheme string) {
 			}
 		}
 		batch := diskdb.NewBatch()
-		if err := sched.Commit(batch, nil); err != nil {
+		if err := sched.Commit(batch); err != nil {
 			t.Fatalf("failed to commit data: %v", err)
 		}
 		batch.Write()
@@ -490,7 +491,7 @@ func testDuplicateAvoidanceSync(t *testing.T, scheme string) {
 			}
 		}
 		batch := diskdb.NewBatch()
-		if err := sched.Commit(batch, nil); err != nil {
+		if err := sched.Commit(batch); err != nil {
 			t.Fatalf("failed to commit data: %v", err)
 		}
 		batch.Write()
@@ -562,7 +563,7 @@ func testIncompleteSync(t *testing.T, scheme string) {
 			}
 		}
 		batch := diskdb.NewBatch()
-		if err := sched.Commit(batch, nil); err != nil {
+		if err := sched.Commit(batch); err != nil {
 			t.Fatalf("failed to commit data: %v", err)
 		}
 		batch.Write()
@@ -652,7 +653,7 @@ func testSyncOrdering(t *testing.T, scheme string) {
 			}
 		}
 		batch := diskdb.NewBatch()
-		if err := sched.Commit(batch, nil); err != nil {
+		if err := sched.Commit(batch); err != nil {
 			t.Fatalf("failed to commit data: %v", err)
 		}
 		batch.Write()
@@ -722,7 +723,7 @@ func syncWithHookWriter(t *testing.T, root common.Hash, db ethdb.Database, srcDb
 			}
 		}
 		batch := db.NewBatch()
-		if err := sched.Commit(batch, nil); err != nil {
+		if err := sched.Commit(batch); err != nil {
 			t.Fatalf("failed to commit data: %v", err)
 		}
 		if hookWriter != nil {