diff --git a/core/chain_makers.go b/core/chain_makers.go index 4033fb77bcb..d97c189d32f 100644 --- a/core/chain_makers.go +++ b/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 } diff --git a/core/state/database_test.go b/core/state/database_test.go index cb0118df136..8dfb2a656d3 100644 --- a/core/state/database_test.go +++ b/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()) } diff --git a/eth/handler_eth_test.go b/eth/handler_eth_test.go index 0071f3ed667..813f8134c22 100644 --- a/eth/handler_eth_test.go +++ b/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) diff --git a/ethdb/kv_mdbx.go b/ethdb/kv_mdbx.go index b7d8b18d43c..5580e18071f 100644 --- a/ethdb/kv_mdbx.go +++ b/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) diff --git a/ethdb/mdbx/env.go b/ethdb/mdbx/env.go index 57301ac8c57..d4c575b91ed 100644 --- a/ethdb/mdbx/env.go +++ b/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. diff --git a/turbo/stages/blockchain_test.go b/turbo/stages/blockchain_test.go index dfb801c8e7e..1744af026eb 100644 --- a/turbo/stages/blockchain_test.go +++ b/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,8 +1085,9 @@ 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) @@ -1095,10 +1095,9 @@ func TestLogReorgs(t *testing.T) { 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,16 +1336,15 @@ 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) } @@ -1353,7 +1352,7 @@ func TestReorgSideEvent(t *testing.T) { 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)