Tests: use transaction instead of db.MemCopy in chain_makers.go

core/chain_makers.go

@@ -230,9 +230,7 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse
 	}
 	blocks, receipts := make(types.Blocks, n), make([]types.Receipts, n)
 	chainreader := &fakeChainReader{config: config}
-	dbCopy := db.MemCopy()
-	defer dbCopy.Close()
-	tx, errBegin := dbCopy.Begin(context.Background(), ethdb.RW)
+	tx, errBegin := db.Begin(context.Background(), ethdb.RW)
 	if errBegin != nil {
 		return nil, nil, errBegin
 	}
@@ -361,9 +359,8 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse
 		parent = block
 	}
 
-	if _, err := tx.Commit(); err != nil {
-		return nil, nil, err
-	}
+	tx.Rollback()
+
 	return blocks, receipts, nil
 }
 

core/state/database_test.go

@@ -903,12 +903,15 @@ func TestCreateOnExistingStorage(t *testing.T) {
 
 	engine := ethash.NewFaker()
 
+	var err error
 	contractBackend := backends.NewSimulatedBackendWithConfig(gspec.Alloc, gspec.Config, gspec.GasLimit)
-	transactOpts := bind.NewKeyedTransactor(key)
+	transactOpts, err := bind.NewKeyedTransactorWithChainID(key, gspec.Config.ChainID)
+	if err != nil {
+		t.Fatal(err)
+	}
 	transactOpts.GasLimit = 1000000
 
 	var contractAddress common.Address
-	var err error
 	// There is one block, and it ends up deploying Revive contract (could be any other contract, it does not really matter)
 	// On the address contractAddr, where there is a storage item in the genesis, but no contract code
 	// We expect the pre-existing storage items to be removed by the deployment
@@ -950,6 +953,7 @@ func TestCreateOnExistingStorage(t *testing.T) {
 	var key0 common.Hash
 	var check0 uint256.Int
 	st.GetState(contractAddress, &key0, &check0)
+	fmt.Printf("c:%t,%x\n", check0.IsZero(), check0.Bytes())
 	if !check0.IsZero() {
 		t.Errorf("expected 0x00 in position 0, got: %x", check0.Bytes())
 	}

eth/handler_eth_test.go

@@ -278,7 +278,7 @@ func testRecvTransactions(t *testing.T, protocol uint) {
 		td      = handler.chain.GetTd(head.Hash(), head.NumberU64())
 	)
 	if err := src.Handshake(1, td, head.Hash(), genesis.Hash(), forkid.NewIDWithChain(handler.chain), forkid.NewFilter(handler.chain)); err != nil {
-		t.Fatalf("failed to run protocol handshake")
+		t.Fatalf("failed to run protocol handshake: %s", err)
 	}
 	// Send the transaction to the sink and verify that it's added to the tx pool
 	tx := types.NewTransaction(0, common.Address{}, uint256.NewInt(), 100000, uint256.NewInt(), nil)

ethdb/kv_mdbx.go

@@ -108,15 +108,26 @@ func (opts MdbxOpts) Open() (KV, error) {
 		return nil, err
 	}
 
-	if opts.flags&mdbx.Accede == 0 {
-		if opts.mapSize == 0 {
-			if opts.inMem {
-				opts.mapSize = 64 * datasize.MB
-			} else {
-				opts.mapSize = LMDBDefaultMapSize
-			}
+	if opts.mapSize == 0 {
+		if opts.inMem {
+			opts.mapSize = 64 * datasize.MB
+		} else {
+			opts.mapSize = LMDBDefaultMapSize
 		}
+	}
 
+	var flags = opts.flags
+	if opts.inMem {
+		flags ^= mdbx.Durable
+		flags |= mdbx.NoMetaSync | mdbx.UtterlyNoSync | mdbx.WriteMap
+		opts.dirtyListMaxPages = 8 * 1024
+	}
+
+	if opts.maxFreelistReuse == 0 {
+		opts.maxFreelistReuse = LMDBDefaultMaxFreelistReuse
+	}
+
+	if opts.flags&mdbx.Accede == 0 {
 		if err = env.SetGeometry(-1, -1, int(opts.mapSize), int(2*datasize.GB), -1, 4*1024); err != nil {
 			return nil, err
 		}
@@ -125,22 +136,11 @@ func (opts MdbxOpts) Open() (KV, error) {
 			return nil, err
 		}
 
-		if opts.maxFreelistReuse == 0 {
-			opts.maxFreelistReuse = LMDBDefaultMaxFreelistReuse
-		}
-
 		if err = os.MkdirAll(opts.path, 0744); err != nil {
 			return nil, fmt.Errorf("could not create dir: %s, %w", opts.path, err)
 		}
 	}
 
-	var flags = opts.flags
-	if opts.inMem {
-		flags ^= mdbx.Durable
-		flags |= mdbx.NoMetaSync | mdbx.SafeNoSync
-		opts.dirtyListMaxPages = 8 * 1024
-	}
-
 	err = env.Open(opts.path, flags, 0664)
 	if err != nil {
 		return nil, fmt.Errorf("%w, path: %s", err, opts.path)

ethdb/mdbx/env.go

@@ -26,15 +26,16 @@ const (
 	EnvDefaults = C.MDBX_ENV_DEFAULTS
 	LifoReclaim = C.MDBX_LIFORECLAIM
 	//FixedMap    = C.MDBX_FIXEDMAP   // Danger zone. Map memory at a fixed address.
-	NoSubdir   = C.MDBX_NOSUBDIR // Argument to Open is a file, not a directory.
-	Accede     = C.MDBX_ACCEDE
-	Coalesce   = C.MDBX_COALESCE
-	Readonly   = C.MDBX_RDONLY     // Used in several functions to denote an object as readonly.
-	WriteMap   = C.MDBX_WRITEMAP   // Use a writable memory map.
-	NoMetaSync = C.MDBX_NOMETASYNC // Don't fsync metapage after commit.
-	SafeNoSync = C.MDBX_SAFE_NOSYNC
-	Durable    = C.MDBX_SYNC_DURABLE
-	NoTLS      = C.MDBX_NOTLS // Danger zone. When unset reader locktable slots are tied to their thread.
+	NoSubdir      = C.MDBX_NOSUBDIR // Argument to Open is a file, not a directory.
+	Accede        = C.MDBX_ACCEDE
+	Coalesce      = C.MDBX_COALESCE
+	Readonly      = C.MDBX_RDONLY     // Used in several functions to denote an object as readonly.
+	WriteMap      = C.MDBX_WRITEMAP   // Use a writable memory map.
+	NoMetaSync    = C.MDBX_NOMETASYNC // Don't fsync metapage after commit.
+	UtterlyNoSync = C.MDBX_UTTERLY_NOSYNC
+	SafeNoSync    = C.MDBX_SAFE_NOSYNC
+	Durable       = C.MDBX_SYNC_DURABLE
+	NoTLS         = C.MDBX_NOTLS // Danger zone. When unset reader locktable slots are tied to their thread.
 	//NoLock      = C.MDBX_NOLOCK     // Danger zone. LMDB does not use any locks.
 	NoReadahead = C.MDBX_NORDAHEAD // Disable readahead. Requires OS support.
 	NoMemInit   = C.MDBX_NOMEMINIT // Disable LMDB memory initialization.

turbo/stages/blockchain_test.go

@@ -960,8 +960,9 @@ func TestLightVsFastVsFullChainHeads(t *testing.T) {
 
 // Tests that chain reorganisations handle transaction removals and reinsertions.
 func TestChainTxReorgs(t *testing.T) {
-	db := ethdb.NewMemDatabase()
+	db, db2 := ethdb.NewMemDatabase(), ethdb.NewMemDatabase()
 	defer db.Close()
+	defer db2.Close()
 	var (
 		key1, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
 		key2, _ = crypto.HexToECDSA("8a1f9a8f95be41cd7ccb6168179afb4504aefe388d1e14474d32c45c72ce7b7a")
@@ -979,12 +980,10 @@ func TestChainTxReorgs(t *testing.T) {
 			},
 		}
 		genesis = gspec.MustCommit(db)
+		_       = gspec.MustCommit(db2)
 		signer  = types.LatestSigner(gspec.Config)
 	)
 
-	genesisDb := db.MemCopy()
-	defer genesisDb.Close()
-
 	// Create two transactions shared between the chains:
 	//  - postponed: transaction included at a later block in the forked chain
 	//  - swapped: transaction included at the same block number in the forked chain
@@ -1002,7 +1001,7 @@ func TestChainTxReorgs(t *testing.T) {
 	//  - futureAdd: transaction added after the reorg has already finished
 	var pastAdd, freshAdd, futureAdd *types.Transaction
 
-	chain, _, err := core.GenerateChain(gspec.Config, genesis, ethash.NewFaker(), genesisDb, 3, func(i int, gen *core.BlockGen) {
+	chain, _, err := core.GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, 3, func(i int, gen *core.BlockGen) {
 		switch i {
 		case 0:
 			pastDrop, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr2), addr2, uint256.NewInt().SetUint64(1000), params.TxGas, nil, nil), signer, key2)
@@ -1028,7 +1027,7 @@ func TestChainTxReorgs(t *testing.T) {
 	}
 
 	// overwrite the old chain
-	chain, _, err = core.GenerateChain(gspec.Config, genesis, ethash.NewFaker(), genesisDb, 5, func(i int, gen *core.BlockGen) {
+	chain, _, err = core.GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db2, 5, func(i int, gen *core.BlockGen) {
 		switch i {
 		case 0:
 			pastAdd, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr3), addr3, uint256.NewInt().SetUint64(1000), params.TxGas, nil, nil), signer, key3)
@@ -1086,19 +1085,19 @@ func TestChainTxReorgs(t *testing.T) {
 }
 
 func TestLogReorgs(t *testing.T) {
-	db := ethdb.NewMemDatabase()
+	db, db2 := ethdb.NewMemDatabase(), ethdb.NewMemoryDatabase()
 	defer db.Close()
+	defer db2.Close()
 	var (
 		key1, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
 		addr1   = crypto.PubkeyToAddress(key1.PublicKey)
 		// this code generates a log
 		code    = common.Hex2Bytes("60606040525b7f24ec1d3ff24c2f6ff210738839dbc339cd45a5294d85c79361016243157aae7b60405180905060405180910390a15b600a8060416000396000f360606040526008565b00")
 		gspec   = &core.Genesis{Config: params.TestChainConfig, Alloc: core.GenesisAlloc{addr1: {Balance: big.NewInt(10000000000000)}}}
 		genesis = gspec.MustCommit(db)
+		_       = gspec.MustCommit(db2)
 		signer  = types.LatestSigner(gspec.Config)
 	)
-	genesisDB := db.MemCopy()
-	defer genesisDB.Close()
 
 	cacheConfig := &core.CacheConfig{
 		TrieCleanLimit: 256,
@@ -1114,7 +1113,7 @@ func TestLogReorgs(t *testing.T) {
 
 	rmLogsCh := make(chan core.RemovedLogsEvent, 10)
 	blockchain.SubscribeRemovedLogsEvent(rmLogsCh)
-	chain, _, err := core.GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), genesisDB, 2, func(i int, gen *core.BlockGen) {
+	chain, _, err := core.GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), db, 2, func(i int, gen *core.BlockGen) {
 		if i == 1 {
 			tx, err := types.SignTx(types.NewContractCreation(gen.TxNonce(addr1), new(uint256.Int), 1000000, new(uint256.Int), code), signer, key1)
 			if err != nil {
@@ -1131,7 +1130,7 @@ func TestLogReorgs(t *testing.T) {
 		t.Fatalf("failed to insert chain: %v", err1)
 	}
 
-	chain, _, err = core.GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), genesisDB, 3, func(i int, gen *core.BlockGen) {}, false /* intemediateHashes */)
+	chain, _, err = core.GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), db2, 3, func(i int, gen *core.BlockGen) {}, false /* intemediateHashes */)
 	if err != nil {
 		t.Fatalf("generate chain: %v", err)
 	}
@@ -1325,8 +1324,9 @@ func checkLogEvents(t *testing.T, logsCh <-chan []*types.Log, rmLogsCh <-chan co
 
 func TestReorgSideEvent(t *testing.T) {
 	t.Skip("should be restored. skipped for turbo-geth. tag: reorg")
-	db := ethdb.NewMemDatabase()
+	db, db2 := ethdb.NewMemDatabase(), ethdb.NewMemDatabase()
 	defer db.Close()
+	defer db2.Close()
 
 	var (
 		key1, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
@@ -1336,24 +1336,23 @@ func TestReorgSideEvent(t *testing.T) {
 			Alloc:  core.GenesisAlloc{addr1: {Balance: big.NewInt(10000000000000)}},
 		}
 		genesis = gspec.MustCommit(db)
+		_       = gspec.MustCommit(db2)
 		signer  = types.LatestSigner(gspec.Config)
 	)
-	genesisDb := db.MemCopy()
-	defer genesisDb.Close()
 
 	txCacher := core.NewTxSenderCacher(1)
 	blockchain, _ := core.NewBlockChain(db, nil, gspec.Config, ethash.NewFaker(), vm.Config{}, nil, txCacher)
 	defer blockchain.Stop()
 
-	chain, _, err := core.GenerateChain(gspec.Config, genesis, ethash.NewFaker(), genesisDb, 3, func(i int, gen *core.BlockGen) {}, false /* intemediateHashes */)
+	chain, _, err := core.GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, 3, func(i int, gen *core.BlockGen) {}, false /* intemediateHashes */)
 	if err != nil {
 		t.Fatalf("generate chain: %v", err)
 	}
 	if _, err = blockchain.InsertChain(context.Background(), chain); err != nil {
 		t.Fatalf("failed to insert chain: %v", err)
 	}
 
-	replacementBlocks, _, err := core.GenerateChain(gspec.Config, genesis, ethash.NewFaker(), genesisDb, 4, func(i int, gen *core.BlockGen) {
+	replacementBlocks, _, err := core.GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db2, 4, func(i int, gen *core.BlockGen) {
 		tx, err := types.SignTx(types.NewContractCreation(gen.TxNonce(addr1), new(uint256.Int), 1000000, new(uint256.Int), nil), signer, key1)
 		if i == 2 {
 			gen.OffsetTime(-9)