From 7b5f91d7edc76c692c3ccd9b8999efd54ea60cdb Mon Sep 17 00:00:00 2001 From: JkLondon Date: Fri, 19 Jul 2024 17:06:43 +0300 Subject: [PATCH 01/53] save --- cmd/evm/runner.go | 3 +- cmd/evm/staterunner.go | 2 +- cmd/integration/commands/stages.go | 2 +- cmd/state/exec3/historical_trace_worker.go | 2 +- cmd/state/exec3/state.go | 2 +- cmd/state/exec3/state_recon.go | 12 ++++-- consensus/aura/aura_test.go | 3 +- core/genesis_test.go | 14 +++---- core/genesis_write.go | 44 ++++++++++------------ eth/backend.go | 2 +- eth/stagedsync/exec3.go | 1 + p2p/sentry/sentry_grpc_server_test.go | 6 +-- tests/state_test.go | 7 ++-- tests/state_test_util.go | 9 +++-- turbo/app/init_cmd.go | 3 +- turbo/stages/genesis_test.go | 32 ++++++++-------- turbo/stages/mock/mock_sentry.go | 2 +- 17 files changed, 76 insertions(+), 70 deletions(-) diff --git a/cmd/evm/runner.go b/cmd/evm/runner.go index 70ca45700a4..380cae72f75 100644 --- a/cmd/evm/runner.go +++ b/cmd/evm/runner.go @@ -24,6 +24,7 @@ import ( "context" "encoding/json" "fmt" + "github.com/erigontech/erigon-lib/common/datadir" "io" "math/big" "os" @@ -158,7 +159,7 @@ func runCmd(ctx *cli.Context) error { defer db.Close() if ctx.String(GenesisFlag.Name) != "" { gen := readGenesis(ctx.String(GenesisFlag.Name)) - core.MustCommitGenesis(gen, db, "", log.Root()) + core.MustCommitGenesis(gen, db, datadir.New(""), log.Root()) genesisConfig = gen chainConfig = gen.Config } else { diff --git a/cmd/evm/staterunner.go b/cmd/evm/staterunner.go index 184274bc748..42349fe52b5 100644 --- a/cmd/evm/staterunner.go +++ b/cmd/evm/staterunner.go @@ -168,7 +168,7 @@ func aggregateResultsFromStateTests( // Run the test and aggregate the result result := &StatetestResult{Name: key, Fork: st.Fork, Pass: true} - statedb, root, err := test.Run(tx, st, cfg) + statedb, root, err := test.Run(tx, st, cfg, dirs) if err != nil { // Test failed, mark as so and dump any state to aid debugging result.Pass, result.Error = false, err.Error() diff --git a/cmd/integration/commands/stages.go b/cmd/integration/commands/stages.go index fc1bc1e028b..6320fc9e6e3 100644 --- a/cmd/integration/commands/stages.go +++ b/cmd/integration/commands/stages.go @@ -1415,7 +1415,7 @@ func newSync(ctx context.Context, db kv.RwDB, miningConfig *params.MiningConfig, events := shards.NewEvents() genesis := core.GenesisBlockByChainName(chain) - chainConfig, genesisBlock, genesisErr := core.CommitGenesisBlock(db, genesis, "", logger) + chainConfig, genesisBlock, genesisErr := core.CommitGenesisBlock(db, genesis, dirs, logger) if _, ok := genesisErr.(*chain2.ConfigCompatError); genesisErr != nil && !ok { panic(genesisErr) } diff --git a/cmd/state/exec3/historical_trace_worker.go b/cmd/state/exec3/historical_trace_worker.go index 61deb36d05b..5cf767edd3a 100644 --- a/cmd/state/exec3/historical_trace_worker.go +++ b/cmd/state/exec3/historical_trace_worker.go @@ -148,7 +148,7 @@ func (rw *HistoricalTraceWorker) RunTxTask(txTask *state.TxTask) { case txTask.TxIndex == -1: if txTask.BlockNum == 0 { // Genesis block - _, ibs, err = core.GenesisToBlock(rw.execArgs.Genesis, rw.execArgs.Dirs.Tmp, rw.logger) + _, ibs, err = core.GenesisToBlock(rw.execArgs.Genesis, rw.execArgs.Dirs, rw.logger) if err != nil { panic(fmt.Errorf("GenesisToBlock: %w", err)) } diff --git a/cmd/state/exec3/state.go b/cmd/state/exec3/state.go index 266a414a07e..ef10170d759 100644 --- a/cmd/state/exec3/state.go +++ b/cmd/state/exec3/state.go @@ -196,7 +196,7 @@ func (rw *Worker) RunTxTaskNoLock(txTask *state.TxTask) { if txTask.BlockNum == 0 { //fmt.Printf("txNum=%d, blockNum=%d, Genesis\n", txTask.TxNum, txTask.BlockNum) - _, ibs, err = core.GenesisToBlock(rw.genesis, rw.dirs.Tmp, rw.logger) + _, ibs, err = core.GenesisToBlock(rw.genesis, rw.dirs, rw.logger) if err != nil { panic(err) } diff --git a/cmd/state/exec3/state_recon.go b/cmd/state/exec3/state_recon.go index 85dd09250b4..e41d24d41b7 100644 --- a/cmd/state/exec3/state_recon.go +++ b/cmd/state/exec3/state_recon.go @@ -20,6 +20,7 @@ import ( "context" "encoding/binary" "fmt" + "github.com/erigontech/erigon-lib/common/datadir" "sync" "github.com/RoaringBitmap/roaring/roaring64" @@ -247,8 +248,9 @@ type ReconWorker struct { genesis *types.Genesis chain *consensuschain.Reader - evm *vm.EVM - ibs *state.IntraBlockState + evm *vm.EVM + ibs *state.IntraBlockState + dirs datadir.Dirs } func NewReconWorker(lock sync.Locker, ctx context.Context, rs *state.ReconState, @@ -284,6 +286,10 @@ func (rw *ReconWorker) SetChainTx(chainTx kv.Tx) { rw.stateWriter.SetChainTx(chainTx) } +func (rw *ReconWorker) SetDirs(dirs datadir.Dirs) { + rw.dirs = dirs +} + func (rw *ReconWorker) Run() error { for txTask, ok, err := rw.rs.Schedule(rw.ctx); ok || err != nil; txTask, ok, err = rw.rs.Schedule(rw.ctx) { if err != nil { @@ -312,7 +318,7 @@ func (rw *ReconWorker) runTxTask(txTask *state.TxTask) error { if txTask.BlockNum == 0 && txTask.TxIndex == -1 { //fmt.Printf("txNum=%d, blockNum=%d, Genesis\n", txTask.TxNum, txTask.BlockNum) // Genesis block - _, ibs, err = core.GenesisToBlock(rw.genesis, "", rw.logger) + _, ibs, err = core.GenesisToBlock(rw.genesis, rw.dirs, rw.logger) if err != nil { return err } diff --git a/consensus/aura/aura_test.go b/consensus/aura/aura_test.go index 5aae977aefb..af080be3825 100644 --- a/consensus/aura/aura_test.go +++ b/consensus/aura/aura_test.go @@ -17,6 +17,7 @@ package aura_test import ( + "github.com/erigontech/erigon-lib/common/datadir" "math/big" "strings" "testing" @@ -41,7 +42,7 @@ import ( func TestEmptyBlock(t *testing.T) { require := require.New(t) genesis := core.GnosisGenesisBlock() - genesisBlock, _, err := core.GenesisToBlock(genesis, "", log.Root()) + genesisBlock, _, err := core.GenesisToBlock(genesis, datadir.New(t.TempDir()), log.Root()) require.NoError(err) genesis.Config.TerminalTotalDifficultyPassed = false diff --git a/core/genesis_test.go b/core/genesis_test.go index 9f11709c624..da32945a4a0 100644 --- a/core/genesis_test.go +++ b/core/genesis_test.go @@ -53,7 +53,7 @@ func TestGenesisBlockHashes(t *testing.T) { t.Fatal(err) } defer tx.Rollback() - _, block, err := core.WriteGenesisBlock(tx, genesis, nil, "", logger) + _, block, err := core.WriteGenesisBlock(tx, genesis, nil, datadir.New(t.TempDir()), logger) require.NoError(t, err) expect := params.GenesisHashByChainName(network) require.NotNil(t, expect, network) @@ -69,12 +69,12 @@ func TestGenesisBlockRoots(t *testing.T) { require := require.New(t) var err error - block, _, _ := core.GenesisToBlock(core.MainnetGenesisBlock(), "", log.Root()) + block, _, _ := core.GenesisToBlock(core.MainnetGenesisBlock(), datadir.New(t.TempDir()), log.Root()) if block.Hash() != params.MainnetGenesisHash { t.Errorf("wrong mainnet genesis hash, got %v, want %v", block.Hash(), params.MainnetGenesisHash) } - block, _, err = core.GenesisToBlock(core.GnosisGenesisBlock(), "", log.Root()) + block, _, err = core.GenesisToBlock(core.GnosisGenesisBlock(), datadir.New(t.TempDir()), log.Root()) require.NoError(err) if block.Root() != params.GnosisGenesisStateRoot { t.Errorf("wrong Gnosis Chain genesis state root, got %v, want %v", block.Root(), params.GnosisGenesisStateRoot) @@ -83,7 +83,7 @@ func TestGenesisBlockRoots(t *testing.T) { t.Errorf("wrong Gnosis Chain genesis hash, got %v, want %v", block.Hash(), params.GnosisGenesisHash) } - block, _, err = core.GenesisToBlock(core.ChiadoGenesisBlock(), "", log.Root()) + block, _, err = core.GenesisToBlock(core.ChiadoGenesisBlock(), datadir.New(t.TempDir()), log.Root()) require.NoError(err) if block.Root() != params.ChiadoGenesisStateRoot { t.Errorf("wrong Chiado genesis state root, got %v, want %v", block.Root(), params.ChiadoGenesisStateRoot) @@ -92,7 +92,7 @@ func TestGenesisBlockRoots(t *testing.T) { t.Errorf("wrong Chiado genesis hash, got %v, want %v", block.Hash(), params.ChiadoGenesisHash) } - block, _, err = core.GenesisToBlock(core.TestGenesisBlock(), "", log.Root()) + block, _, err = core.GenesisToBlock(core.TestGenesisBlock(), datadir.New(t.TempDir()), log.Root()) require.NoError(err) if block.Root() != params.TestGenesisStateRoot { t.Errorf("wrong Chiado genesis state root, got %v, want %v", block.Root(), params.TestGenesisStateRoot) @@ -111,13 +111,13 @@ func TestCommitGenesisIdempotency(t *testing.T) { defer tx.Rollback() genesis := core.GenesisBlockByChainName(networkname.MainnetChainName) - _, _, err = core.WriteGenesisBlock(tx, genesis, nil, "", logger) + _, _, err = core.WriteGenesisBlock(tx, genesis, nil, datadir.New(t.TempDir()), logger) require.NoError(t, err) seq, err := tx.ReadSequence(kv.EthTx) require.NoError(t, err) require.Equal(t, uint64(2), seq) - _, _, err = core.WriteGenesisBlock(tx, genesis, nil, "", logger) + _, _, err = core.WriteGenesisBlock(tx, genesis, nil, datadir.New(t.TempDir()), logger) require.NoError(t, err) seq, err = tx.ReadSequence(kv.EthTx) require.NoError(t, err) diff --git a/core/genesis_write.go b/core/genesis_write.go index 8df012674db..ba310485dc7 100644 --- a/core/genesis_write.go +++ b/core/genesis_write.go @@ -26,7 +26,6 @@ import ( "encoding/json" "fmt" "math/big" - "os" "slices" "github.com/c2h5oh/datasize" @@ -74,17 +73,17 @@ var allocs embed.FS // error is a *params.ConfigCompatError and the new, unwritten config is returned. // // The returned chain configuration is never nil. -func CommitGenesisBlock(db kv.RwDB, genesis *types.Genesis, tmpDir string, logger log.Logger) (*chain.Config, *types.Block, error) { - return CommitGenesisBlockWithOverride(db, genesis, nil, tmpDir, logger) +func CommitGenesisBlock(db kv.RwDB, genesis *types.Genesis, dirs datadir.Dirs, logger log.Logger) (*chain.Config, *types.Block, error) { + return CommitGenesisBlockWithOverride(db, genesis, nil, dirs, logger) } -func CommitGenesisBlockWithOverride(db kv.RwDB, genesis *types.Genesis, overridePragueTime *big.Int, tmpDir string, logger log.Logger) (*chain.Config, *types.Block, error) { +func CommitGenesisBlockWithOverride(db kv.RwDB, genesis *types.Genesis, overridePragueTime *big.Int, dirs datadir.Dirs, logger log.Logger) (*chain.Config, *types.Block, error) { tx, err := db.BeginRw(context.Background()) if err != nil { return nil, nil, err } defer tx.Rollback() - c, b, err := WriteGenesisBlock(tx, genesis, overridePragueTime, tmpDir, logger) + c, b, err := WriteGenesisBlock(tx, genesis, overridePragueTime, dirs, logger) if err != nil { return c, b, err } @@ -95,7 +94,7 @@ func CommitGenesisBlockWithOverride(db kv.RwDB, genesis *types.Genesis, override return c, b, nil } -func WriteGenesisBlock(tx kv.RwTx, genesis *types.Genesis, overridePragueTime *big.Int, tmpDir string, logger log.Logger) (*chain.Config, *types.Block, error) { +func WriteGenesisBlock(tx kv.RwTx, genesis *types.Genesis, overridePragueTime *big.Int, dirs datadir.Dirs, logger log.Logger) (*chain.Config, *types.Block, error) { if err := rawdb.WriteGenesis(tx, genesis); err != nil { return nil, nil, err } @@ -124,7 +123,7 @@ func WriteGenesisBlock(tx kv.RwTx, genesis *types.Genesis, overridePragueTime *b custom = false } applyOverrides(genesis.Config) - block, _, err1 := write(tx, genesis, tmpDir, logger) + block, _, err1 := write(tx, genesis, dirs, logger) if err1 != nil { return genesis.Config, nil, err1 } @@ -136,7 +135,7 @@ func WriteGenesisBlock(tx kv.RwTx, genesis *types.Genesis, overridePragueTime *b // Check whether the genesis block is already written. if genesis != nil { - block, _, err1 := GenesisToBlock(genesis, tmpDir, logger) + block, _, err1 := GenesisToBlock(genesis, dirs, logger) if err1 != nil { return genesis.Config, nil, err1 } @@ -193,8 +192,8 @@ func WriteGenesisBlock(tx kv.RwTx, genesis *types.Genesis, overridePragueTime *b return newCfg, storedBlock, nil } -func WriteGenesisState(g *types.Genesis, tx kv.RwTx, tmpDir string, logger log.Logger) (*types.Block, *state.IntraBlockState, error) { - block, statedb, err := GenesisToBlock(g, tmpDir, logger) +func WriteGenesisState(g *types.Genesis, tx kv.RwTx, dirs datadir.Dirs, logger log.Logger) (*types.Block, *state.IntraBlockState, error) { + block, statedb, err := GenesisToBlock(g, dirs, logger) if err != nil { return nil, nil, err } @@ -212,13 +211,13 @@ func WriteGenesisState(g *types.Genesis, tx kv.RwTx, tmpDir string, logger log.L return block, statedb, nil } -func MustCommitGenesis(g *types.Genesis, db kv.RwDB, tmpDir string, logger log.Logger) *types.Block { +func MustCommitGenesis(g *types.Genesis, db kv.RwDB, dirs datadir.Dirs, logger log.Logger) *types.Block { tx, err := db.BeginRw(context.Background()) if err != nil { panic(err) } defer tx.Rollback() - block, _, err := write(tx, g, tmpDir, logger) + block, _, err := write(tx, g, dirs, logger) if err != nil { panic(err) } @@ -231,8 +230,8 @@ func MustCommitGenesis(g *types.Genesis, db kv.RwDB, tmpDir string, logger log.L // Write writes the block and state of a genesis specification to the database. // The block is committed as the canonical head block. -func write(tx kv.RwTx, g *types.Genesis, tmpDir string, logger log.Logger) (*types.Block, *state.IntraBlockState, error) { - block, statedb, err2 := WriteGenesisState(g, tx, tmpDir, logger) +func write(tx kv.RwTx, g *types.Genesis, dirs datadir.Dirs, logger log.Logger) (*types.Block, *state.IntraBlockState, error) { + block, statedb, err2 := WriteGenesisState(g, tx, dirs, logger) if err2 != nil { return block, statedb, err2 } @@ -289,9 +288,9 @@ func write(tx kv.RwTx, g *types.Genesis, tmpDir string, logger log.Logger) (*typ } // GenesisBlockForTesting creates and writes a block in which addr has the given wei balance. -func GenesisBlockForTesting(db kv.RwDB, addr libcommon.Address, balance *big.Int, tmpDir string, logger log.Logger) *types.Block { +func GenesisBlockForTesting(db kv.RwDB, addr libcommon.Address, balance *big.Int, dirs datadir.Dirs, logger log.Logger) *types.Block { g := types.Genesis{Alloc: types.GenesisAlloc{addr: {Balance: balance}}, Config: params.TestChainConfig} - block := MustCommitGenesis(&g, db, tmpDir, logger) + block := MustCommitGenesis(&g, db, dirs, logger) return block } @@ -300,14 +299,14 @@ type GenAccount struct { Balance *big.Int } -func GenesisWithAccounts(db kv.RwDB, accs []GenAccount, tmpDir string, logger log.Logger) *types.Block { +func GenesisWithAccounts(db kv.RwDB, accs []GenAccount, dirs datadir.Dirs, logger log.Logger) *types.Block { g := types.Genesis{Config: params.TestChainConfig} allocs := make(map[libcommon.Address]types.GenesisAccount) for _, acc := range accs { allocs[acc.Addr] = types.GenesisAccount{Balance: acc.Balance} } g.Alloc = allocs - block := MustCommitGenesis(&g, db, tmpDir, logger) + block := MustCommitGenesis(&g, db, dirs, logger) return block } @@ -460,7 +459,7 @@ func DeveloperGenesisBlock(period uint64, faucet libcommon.Address) *types.Genes // ToBlock creates the genesis block and writes state of a genesis specification // to the given database (or discards it if nil). -func GenesisToBlock(g *types.Genesis, tmpDir string, logger log.Logger) (*types.Block, *state.IntraBlockState, error) { +func GenesisToBlock(g *types.Genesis, dirs datadir.Dirs, logger log.Logger) (*types.Block, *state.IntraBlockState, error) { _ = g.Alloc //nil-check head := &types.Header{ @@ -537,15 +536,12 @@ func GenesisToBlock(g *types.Genesis, tmpDir string, logger log.Logger) (*types. wg, ctx := errgroup.WithContext(ctx) // we may run inside write tx, can't open 2nd write tx in same goroutine wg.Go(func() error { - if tmpDir == "" { - tmpDir = os.TempDir() - } // some users creaing > 1Gb custome genesis by `erigon init` - genesisTmpDB := mdbx.NewMDBX(logger).InMem(tmpDir).MapSize(2 * datasize.GB).GrowthStep(1 * datasize.MB).MustOpen() + genesisTmpDB := mdbx.NewMDBX(logger).InMem(dirs.DataDir).MapSize(2 * datasize.GB).GrowthStep(1 * datasize.MB).MustOpen() defer genesisTmpDB.Close() cr := rawdb.NewCanonicalReader() - agg, err := state2.NewAggregator(context.Background(), datadir.New(tmpDir), config3.HistoryV3AggregationStep, genesisTmpDB, cr, logger) + agg, err := state2.NewAggregator(context.Background(), dirs, config3.HistoryV3AggregationStep, genesisTmpDB, cr, logger) if err != nil { return err } diff --git a/eth/backend.go b/eth/backend.go index ac8efe9394d..acb7b1ae354 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -314,7 +314,7 @@ func New(ctx context.Context, stack *node.Node, config *ethconfig.Config, logger genesisSpec = nil } var genesisErr error - chainConfig, genesis, genesisErr = core.WriteGenesisBlock(tx, genesisSpec, config.OverridePragueTime, tmpdir, logger) + chainConfig, genesis, genesisErr = core.WriteGenesisBlock(tx, genesisSpec, config.OverridePragueTime, dirs, logger) if _, ok := genesisErr.(*chain.ConfigCompatError); genesisErr != nil && !ok { return genesisErr } diff --git a/eth/stagedsync/exec3.go b/eth/stagedsync/exec3.go index 4aa51a78eea..7f4d1148066 100644 --- a/eth/stagedsync/exec3.go +++ b/eth/stagedsync/exec3.go @@ -1318,6 +1318,7 @@ func reconstituteStep(last bool, reconWorkers[i] = exec3.NewReconWorker(lock.RLocker(), reconstWorkersCtx, rs, localAs, blockReader, chainConfig, logger, genesis, engine, chainTxs[i]) reconWorkers[i].SetTx(roTxs[i]) reconWorkers[i].SetChainTx(chainTxs[i]) + reconWorkers[i].SetDirs(dirs) } rollbackCount := uint64(0) diff --git a/p2p/sentry/sentry_grpc_server_test.go b/p2p/sentry/sentry_grpc_server_test.go index 079301d1a92..03fdd4ddaf5 100644 --- a/p2p/sentry/sentry_grpc_server_test.go +++ b/p2p/sentry/sentry_grpc_server_test.go @@ -105,8 +105,8 @@ func testForkIDSplit(t *testing.T, protocol uint) { gspecNoFork = &types.Genesis{Config: configNoFork} gspecProFork = &types.Genesis{Config: configProFork} - genesisNoFork = core.MustCommitGenesis(gspecNoFork, dbNoFork, "", log.Root()) - genesisProFork = core.MustCommitGenesis(gspecProFork, dbProFork, "", log.Root()) + genesisNoFork = core.MustCommitGenesis(gspecNoFork, dbNoFork, datadir.New(t.TempDir()), log.Root()) + genesisProFork = core.MustCommitGenesis(gspecProFork, dbProFork, datadir.New(t.TempDir()), log.Root()) ) var s1, s2 *GrpcServer @@ -194,7 +194,7 @@ func TestSentryServerImpl_SetStatusInitPanic(t *testing.T) { configNoFork := &chain.Config{HomesteadBlock: big.NewInt(1), ChainID: big.NewInt(1)} dbNoFork, _ := temporaltest.NewTestDB(t, datadir.New(t.TempDir())) gspecNoFork := &types.Genesis{Config: configNoFork} - genesisNoFork := core.MustCommitGenesis(gspecNoFork, dbNoFork, "", log.Root()) + genesisNoFork := core.MustCommitGenesis(gspecNoFork, dbNoFork, datadir.New(t.TempDir()), log.Root()) ss := &GrpcServer{p2p: &p2p.Config{}} _, err := ss.SetStatus(context.Background(), &proto_sentry.StatusData{ diff --git a/tests/state_test.go b/tests/state_test.go index 5a1cc735e67..19871fdf2de 100644 --- a/tests/state_test.go +++ b/tests/state_test.go @@ -30,7 +30,6 @@ import ( "runtime" "testing" - "github.com/erigontech/erigon-lib/common/datadir" "github.com/erigontech/erigon-lib/kv/temporal/temporaltest" "github.com/erigontech/erigon-lib/log/v3" @@ -60,8 +59,8 @@ func TestState(t *testing.T) { st.skipLoad(`.*vmPerformance/loop.*`) //if ethconfig.EnableHistoryV3InTest { //} - - db, _ := temporaltest.NewTestDB(t, datadir.New(t.TempDir())) + dirs := datadir.New(t.TempDir()) + db, _ := temporaltest.NewTestDB(t, dirs) st.walk(t, stateTestDir, func(t *testing.T, name string, test *StateTest) { for _, subtest := range test.Subtests() { subtest := subtest @@ -73,7 +72,7 @@ func TestState(t *testing.T) { t.Fatal(err) } defer tx.Rollback() - _, _, err = test.Run(tx, subtest, vmconfig) + _, _, err = test.Run(tx, subtest, vmconfig, dirs) tx.Rollback() if err != nil && len(test.json.Post[subtest.Fork][subtest.Index].ExpectException) > 0 { // Ignore expected errors diff --git a/tests/state_test_util.go b/tests/state_test_util.go index 5b8079692f9..d5a0bf503a1 100644 --- a/tests/state_test_util.go +++ b/tests/state_test_util.go @@ -25,6 +25,7 @@ import ( "encoding/hex" "encoding/json" "fmt" + "github.com/erigontech/erigon-lib/common/datadir" "math/big" "strconv" "strings" @@ -165,8 +166,8 @@ func (t *StateTest) Subtests() []StateSubtest { } // Run executes a specific subtest and verifies the post-state and logs -func (t *StateTest) Run(tx kv.RwTx, subtest StateSubtest, vmconfig vm.Config) (*state.IntraBlockState, libcommon.Hash, error) { - state, root, err := t.RunNoVerify(tx, subtest, vmconfig) +func (t *StateTest) Run(tx kv.RwTx, subtest StateSubtest, vmconfig vm.Config, dirs datadir.Dirs) (*state.IntraBlockState, libcommon.Hash, error) { + state, root, err := t.RunNoVerify(tx, subtest, vmconfig, dirs) if err != nil { return state, types.EmptyRootHash, err } @@ -183,13 +184,13 @@ func (t *StateTest) Run(tx kv.RwTx, subtest StateSubtest, vmconfig vm.Config) (* } // RunNoVerify runs a specific subtest and returns the statedb and post-state root -func (t *StateTest) RunNoVerify(tx kv.RwTx, subtest StateSubtest, vmconfig vm.Config) (*state.IntraBlockState, libcommon.Hash, error) { +func (t *StateTest) RunNoVerify(tx kv.RwTx, subtest StateSubtest, vmconfig vm.Config, dirs datadir.Dirs) (*state.IntraBlockState, libcommon.Hash, error) { config, eips, err := GetChainConfig(subtest.Fork) if err != nil { return nil, libcommon.Hash{}, UnsupportedForkError{subtest.Fork} } vmconfig.ExtraEips = eips - block, _, err := core.GenesisToBlock(t.genesis(config), "", log.Root()) + block, _, err := core.GenesisToBlock(t.genesis(config), dirs, log.Root()) if err != nil { return nil, libcommon.Hash{}, UnsupportedForkError{subtest.Fork} } diff --git a/turbo/app/init_cmd.go b/turbo/app/init_cmd.go index e329b08ac6c..1ceb905763e 100644 --- a/turbo/app/init_cmd.go +++ b/turbo/app/init_cmd.go @@ -18,6 +18,7 @@ package app import ( "encoding/json" + "github.com/erigontech/erigon-lib/common/datadir" "os" "github.com/urfave/cli/v2" @@ -82,7 +83,7 @@ func initGenesis(cliCtx *cli.Context) error { if err != nil { utils.Fatalf("Failed to open database: %v", err) } - _, hash, err := core.CommitGenesisBlock(chaindb, genesis, "", logger) + _, hash, err := core.CommitGenesisBlock(chaindb, genesis, datadir.New(""), logger) if err != nil { utils.Fatalf("Failed to write genesis block: %v", err) } diff --git a/turbo/stages/genesis_test.go b/turbo/stages/genesis_test.go index 87616166cf5..d3fee48eaa3 100644 --- a/turbo/stages/genesis_test.go +++ b/turbo/stages/genesis_test.go @@ -68,7 +68,7 @@ func TestSetupGenesis(t *testing.T) { { name: "genesis without ChainConfig", fn: func(t *testing.T, db kv.RwDB) (*chain.Config, *types.Block, error) { - return core.CommitGenesisBlock(db, new(types.Genesis), tmpdir, logger) + return core.CommitGenesisBlock(db, new(types.Genesis), datadir.New(tmpdir), logger) }, wantErr: types.ErrGenesisNoConfig, wantConfig: params.AllProtocolChanges, @@ -76,7 +76,7 @@ func TestSetupGenesis(t *testing.T) { { name: "no block in DB, genesis == nil", fn: func(t *testing.T, db kv.RwDB) (*chain.Config, *types.Block, error) { - return core.CommitGenesisBlock(db, nil, tmpdir, logger) + return core.CommitGenesisBlock(db, nil, datadir.New(tmpdir), logger) }, wantHash: params.MainnetGenesisHash, wantConfig: params.MainnetChainConfig, @@ -84,7 +84,7 @@ func TestSetupGenesis(t *testing.T) { { name: "mainnet block in DB, genesis == nil", fn: func(t *testing.T, db kv.RwDB) (*chain.Config, *types.Block, error) { - return core.CommitGenesisBlock(db, nil, tmpdir, logger) + return core.CommitGenesisBlock(db, nil, datadir.New(tmpdir), logger) }, wantHash: params.MainnetGenesisHash, wantConfig: params.MainnetChainConfig, @@ -92,8 +92,8 @@ func TestSetupGenesis(t *testing.T) { { name: "custom block in DB, genesis == nil", fn: func(t *testing.T, db kv.RwDB) (*chain.Config, *types.Block, error) { - core.MustCommitGenesis(&customg, db, tmpdir, logger) - return core.CommitGenesisBlock(db, nil, tmpdir, logger) + core.MustCommitGenesis(&customg, db, datadir.New(tmpdir), logger) + return core.CommitGenesisBlock(db, nil, datadir.New(tmpdir), logger) }, wantHash: customghash, wantConfig: customg.Config, @@ -101,8 +101,8 @@ func TestSetupGenesis(t *testing.T) { { name: "custom block in DB, genesis == sepolia", fn: func(t *testing.T, db kv.RwDB) (*chain.Config, *types.Block, error) { - core.MustCommitGenesis(&customg, db, tmpdir, logger) - return core.CommitGenesisBlock(db, core.SepoliaGenesisBlock(), tmpdir, logger) + core.MustCommitGenesis(&customg, db, datadir.New(tmpdir), logger) + return core.CommitGenesisBlock(db, core.SepoliaGenesisBlock(), datadir.New(tmpdir), logger) }, wantErr: &types.GenesisMismatchError{Stored: customghash, New: params.SepoliaGenesisHash}, wantHash: params.SepoliaGenesisHash, @@ -111,8 +111,8 @@ func TestSetupGenesis(t *testing.T) { { name: "custom block in DB, genesis == bor-mainnet", fn: func(t *testing.T, db kv.RwDB) (*chain.Config, *types.Block, error) { - core.MustCommitGenesis(&customg, db, tmpdir, logger) - return core.CommitGenesisBlock(db, core.BorMainnetGenesisBlock(), tmpdir, logger) + core.MustCommitGenesis(&customg, db, datadir.New(tmpdir), logger) + return core.CommitGenesisBlock(db, core.BorMainnetGenesisBlock(), datadir.New(tmpdir), logger) }, wantErr: &types.GenesisMismatchError{Stored: customghash, New: params.BorMainnetGenesisHash}, wantHash: params.BorMainnetGenesisHash, @@ -121,8 +121,8 @@ func TestSetupGenesis(t *testing.T) { { name: "custom block in DB, genesis == mumbai", fn: func(t *testing.T, db kv.RwDB) (*chain.Config, *types.Block, error) { - core.MustCommitGenesis(&customg, db, tmpdir, logger) - return core.CommitGenesisBlock(db, core.MumbaiGenesisBlock(), tmpdir, logger) + core.MustCommitGenesis(&customg, db, datadir.New(tmpdir), logger) + return core.CommitGenesisBlock(db, core.MumbaiGenesisBlock(), datadir.New(tmpdir), logger) }, wantErr: &types.GenesisMismatchError{Stored: customghash, New: params.MumbaiGenesisHash}, wantHash: params.MumbaiGenesisHash, @@ -131,8 +131,8 @@ func TestSetupGenesis(t *testing.T) { { name: "custom block in DB, genesis == amoy", fn: func(t *testing.T, db kv.RwDB) (*chain.Config, *types.Block, error) { - core.MustCommitGenesis(&customg, db, tmpdir, logger) - return core.CommitGenesisBlock(db, core.AmoyGenesisBlock(), tmpdir, logger) + core.MustCommitGenesis(&customg, db, datadir.New(tmpdir), logger) + return core.CommitGenesisBlock(db, core.AmoyGenesisBlock(), datadir.New(tmpdir), logger) }, wantErr: &types.GenesisMismatchError{Stored: customghash, New: params.AmoyGenesisHash}, wantHash: params.AmoyGenesisHash, @@ -141,8 +141,8 @@ func TestSetupGenesis(t *testing.T) { { name: "compatible config in DB", fn: func(t *testing.T, db kv.RwDB) (*chain.Config, *types.Block, error) { - core.MustCommitGenesis(&oldcustomg, db, tmpdir, logger) - return core.CommitGenesisBlock(db, &customg, tmpdir, logger) + core.MustCommitGenesis(&oldcustomg, db, datadir.New(tmpdir), logger) + return core.CommitGenesisBlock(db, &customg, datadir.New(tmpdir), logger) }, wantHash: customghash, wantConfig: customg.Config, @@ -166,7 +166,7 @@ func TestSetupGenesis(t *testing.T) { return nil, nil, err } // This should return a compatibility error. - return core.CommitGenesisBlock(m.DB, &customg, tmpdir, logger) + return core.CommitGenesisBlock(m.DB, &customg, datadir.New(tmpdir), logger) }, wantHash: customghash, wantConfig: customg.Config, diff --git a/turbo/stages/mock/mock_sentry.go b/turbo/stages/mock/mock_sentry.go index c744982191b..593b09caf84 100644 --- a/turbo/stages/mock/mock_sentry.go +++ b/turbo/stages/mock/mock_sentry.go @@ -356,7 +356,7 @@ func MockWithEverything(tb testing.TB, gspec *types.Genesis, key *ecdsa.PrivateK } // Committed genesis will be shared between download and mock sentry - _, mock.Genesis, err = core.CommitGenesisBlock(mock.DB, gspec, "", mock.Log) + _, mock.Genesis, err = core.CommitGenesisBlock(mock.DB, gspec, datadir.New(tmpdir), mock.Log) if _, ok := err.(*chain.ConfigCompatError); err != nil && !ok { if tb != nil { tb.Fatal(err) From 69ce8483181d3e5961e76ece9413fcd552525cb0 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Wed, 24 Jul 2024 11:08:15 +0300 Subject: [PATCH 02/53] trying to fix --- tests/bor/mining_test.go | 42 +++++++++++++++++++++++++++------------- 1 file changed, 29 insertions(+), 13 deletions(-) diff --git a/tests/bor/mining_test.go b/tests/bor/mining_test.go index 8a43b96b057..c52d677890d 100644 --- a/tests/bor/mining_test.go +++ b/tests/bor/mining_test.go @@ -1,4 +1,4 @@ -//go:build integration +////go:build integration package bor @@ -14,7 +14,6 @@ import ( "github.com/holiman/uint256" "github.com/erigontech/erigon-lib/chain/networkname" - "github.com/erigontech/erigon-lib/config3" "github.com/erigontech/erigon-lib/gointerfaces" remote "github.com/erigontech/erigon-lib/gointerfaces/remoteproto" txpool "github.com/erigontech/erigon-lib/gointerfaces/txpoolproto" @@ -56,9 +55,9 @@ var ( // Example : CGO_CFLAGS="-D__BLST_PORTABLE__" go test -run ^TestMiningBenchmark$ github.com/erigontech/erigon/tests/bor -v -count=1 // In TestMiningBenchmark, we will test the mining performance. We will initialize a single node devnet and fire 5000 txs. We will measure the time it takes to include all the txs. This can be made more advcanced by increasing blockLimit and txsInTxpool. func TestMiningBenchmark(t *testing.T) { - if config3.EnableHistoryV4InTest { - t.Skip("TODO: [e4] implement me") - } + //if config3.EnableHistoryV4InTest { + // t.Skip("TODO: [e4] implement me") + //} log.Root().SetHandler(log.LvlFilterHandler(log.LvlWarn, log.StreamHandler(os.Stderr, log.TerminalFormat()))) fdlimit.Raise(2048) @@ -105,8 +104,11 @@ func TestMiningBenchmark(t *testing.T) { initNonce := uint64(0) for i := 0; i < txInTxpool; i++ { - txn := *newRandomTxWithNonce(false, initNonce+uint64(i), ethbackends[0].TxpoolServer()) - txs = append(txs, &txn) + txn, err := newRandomTxWithNonce(false, initNonce+uint64(i), ethbackends[0].TxpoolServer()) + if err != nil { + panic(err) + } + txs = append(txs, txn) } start := time.Now() @@ -118,7 +120,11 @@ func TestMiningBenchmark(t *testing.T) { if err != nil { panic(err) } - ethbackends[0].TxpoolServer().Add(context.Background(), &txpool.AddRequest{RlpTxs: [][]byte{buf.Bytes()}}) + resp, err := ethbackends[0].TxpoolServer().Add(context.Background(), &txpool.AddRequest{RlpTxs: [][]byte{buf.Bytes()}}) + if err != nil { + panic(err) + } + println(fmt.Sprintf("%+v", resp)) } for { @@ -141,17 +147,27 @@ func TestMiningBenchmark(t *testing.T) { } // newRandomTxWithNonce creates a new transaction with the given nonce. -func newRandomTxWithNonce(creation bool, nonce uint64, txPool txpool_proto.TxpoolServer) *types.Transaction { +func newRandomTxWithNonce(creation bool, nonce uint64, txPool txpool_proto.TxpoolServer) (tx *types.Transaction, err error) { var txn types.Transaction gasPrice := uint256.NewInt(100 * params.InitialBaseFee) if creation { - nonce, _ := txPool.Nonce(context.Background(), &txpool_proto.NonceRequest{Address: gointerfaces.ConvertAddressToH160(addr1)}) - txn, _ = types.SignTx(types.NewContractCreation(nonce.Nonce, uint256.NewInt(0), testGas, gasPrice, common.FromHex(testCode)), *types.LatestSignerForChainID(nil), pkey1) + var nonceReply *txpool_proto.NonceReply + nonceReply, err = txPool.Nonce(context.Background(), &txpool_proto.NonceRequest{Address: gointerfaces.ConvertAddressToH160(addr1)}) + if err != nil { + return nil, err + } + txn, err = types.SignTx(types.NewContractCreation(nonceReply.Nonce, uint256.NewInt(0), testGas, gasPrice, common.FromHex(testCode)), *types.LatestSignerForChainID(nil), pkey1) + if err != nil { + return nil, err + } } else { - txn, _ = types.SignTx(types.NewTransaction(nonce, addr2, uint256.NewInt(1000), params.TxGas, gasPrice, nil), *types.LatestSignerForChainID(nil), pkey1) + txn, err = types.SignTx(types.NewTransaction(nonce, addr2, uint256.NewInt(1000), params.TxGas, gasPrice, nil), *types.LatestSignerForChainID(nil), pkey1) + if err != nil { + return nil, err + } } - return &txn + return &txn, nil } From 737017cdf4165c48f2f6d21cafe5fca2e2de6931 Mon Sep 17 00:00:00 2001 From: "alex.sharov" Date: Sun, 28 Jul 2024 11:33:53 +0700 Subject: [PATCH 03/53] save --- tests/state_test.go | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/state_test.go b/tests/state_test.go index 19871fdf2de..b5cc541e756 100644 --- a/tests/state_test.go +++ b/tests/state_test.go @@ -30,6 +30,7 @@ import ( "runtime" "testing" + "github.com/erigontech/erigon-lib/common/datadir" "github.com/erigontech/erigon-lib/kv/temporal/temporaltest" "github.com/erigontech/erigon-lib/log/v3" From 917abde8114086e91b933435d6ba49d4df9bdde5 Mon Sep 17 00:00:00 2001 From: "alex.sharov" Date: Sun, 28 Jul 2024 15:37:53 +0700 Subject: [PATCH 04/53] save --- turbo/jsonrpc/txpool_api_test.go | 5 ----- 1 file changed, 5 deletions(-) diff --git a/turbo/jsonrpc/txpool_api_test.go b/turbo/jsonrpc/txpool_api_test.go index c46cb1a67fa..9b5a7662c02 100644 --- a/turbo/jsonrpc/txpool_api_test.go +++ b/turbo/jsonrpc/txpool_api_test.go @@ -26,7 +26,6 @@ import ( libcommon "github.com/erigontech/erigon-lib/common" "github.com/erigontech/erigon-lib/common/hexutil" - "github.com/erigontech/erigon-lib/config3" txpool "github.com/erigontech/erigon-lib/gointerfaces/txpoolproto" "github.com/erigontech/erigon-lib/kv/kvcache" @@ -40,10 +39,6 @@ import ( ) func TestTxPoolContent(t *testing.T) { - if config3.EnableHistoryV4InTest { - t.Skip("TODO: [e4] implement me") - } - m, require := mock.MockWithTxPool(t), require.New(t) chain, err := core.GenerateChain(m.ChainConfig, m.Genesis, m.Engine, m.DB, 1, func(i int, b *core.BlockGen) { b.SetCoinbase(libcommon.Address{1}) From ff5228649f455d7340fd5970e042e9f5df74c1ac Mon Sep 17 00:00:00 2001 From: "alex.sharov" Date: Sun, 28 Jul 2024 18:18:20 +0700 Subject: [PATCH 05/53] save --- core/genesis_write.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/core/genesis_write.go b/core/genesis_write.go index ba310485dc7..fb0ae979996 100644 --- a/core/genesis_write.go +++ b/core/genesis_write.go @@ -460,6 +460,10 @@ func DeveloperGenesisBlock(period uint64, faucet libcommon.Address) *types.Genes // ToBlock creates the genesis block and writes state of a genesis specification // to the given database (or discards it if nil). func GenesisToBlock(g *types.Genesis, dirs datadir.Dirs, logger log.Logger) (*types.Block, *state.IntraBlockState, error) { + if dirs.SnapDomain == "" { + panic("empty `dirs` variable") + } + _ = g.Alloc //nil-check head := &types.Header{ From a29516484fa7b4a7ac278cb11d5fe08ef07c2239 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Mon, 29 Jul 2024 10:29:43 +0300 Subject: [PATCH 06/53] save --- cmd/integration/commands/state_stages.go | 2 +- eth/stagedsync/stage_mining_create_block.go | 2 +- eth/stagedsync/stagebuilder.go | 2 +- tests/bor/helper/miner.go | 9 ++++----- tests/bor/mining_test.go | 6 ++---- 5 files changed, 9 insertions(+), 12 deletions(-) diff --git a/cmd/integration/commands/state_stages.go b/cmd/integration/commands/state_stages.go index 37c958ef560..b5baf7b3efe 100644 --- a/cmd/integration/commands/state_stages.go +++ b/cmd/integration/commands/state_stages.go @@ -300,7 +300,7 @@ func syncBySmallSteps(db kv.RwDB, miningConfig params.MiningConfig, ctx context. miner.MiningConfig.Etherbase = nextBlock.Coinbase() miner.MiningConfig.ExtraData = nextBlock.Extra() miningStages.MockExecFunc(stages.MiningCreateBlock, func(badBlockUnwind bool, s *stagedsync.StageState, u stagedsync.Unwinder, txc wrap.TxContainer, logger log.Logger) error { - err = stagedsync.SpawnMiningCreateBlockStage(s, txc.Tx, + err = stagedsync.SpawnMiningCreateBlockStage(s, txc.Ttx, stagedsync.StageMiningCreateBlockCfg(db, miner, *chainConfig, engine, nil, nil, dirs.Tmp, br), quit, logger) if err != nil { diff --git a/eth/stagedsync/stage_mining_create_block.go b/eth/stagedsync/stage_mining_create_block.go index c312ddab0d9..7dce179981b 100644 --- a/eth/stagedsync/stage_mining_create_block.go +++ b/eth/stagedsync/stage_mining_create_block.go @@ -108,7 +108,7 @@ var maxTransactions uint16 = 1000 // SpawnMiningCreateBlockStage // TODO: // - resubmitAdjustCh - variable is not implemented -func SpawnMiningCreateBlockStage(s *StageState, tx kv.RwTx, cfg MiningCreateBlockCfg, quit <-chan struct{}, logger log.Logger) (err error) { +func SpawnMiningCreateBlockStage(s *StageState, tx kv.TemporalTx, cfg MiningCreateBlockCfg, quit <-chan struct{}, logger log.Logger) (err error) { current := cfg.miner.MiningBlock txPoolLocals := []libcommon.Address{} //txPoolV2 has no concept of local addresses (yet?) coinbase := cfg.miner.MiningConfig.Etherbase diff --git a/eth/stagedsync/stagebuilder.go b/eth/stagedsync/stagebuilder.go index 5352b6a4303..d72c314d6db 100644 --- a/eth/stagedsync/stagebuilder.go +++ b/eth/stagedsync/stagebuilder.go @@ -49,7 +49,7 @@ func MiningStages( ID: stages.MiningCreateBlock, Description: "Mining: construct new block from txn pool", Forward: func(badBlockUnwind bool, s *StageState, u Unwinder, txc wrap.TxContainer, logger log.Logger) error { - return SpawnMiningCreateBlockStage(s, txc.Tx, createBlockCfg, ctx.Done(), logger) + return SpawnMiningCreateBlockStage(s, txc.Ttx, createBlockCfg, ctx.Done(), logger) }, Unwind: func(u *UnwindState, s *StageState, txc wrap.TxContainer, logger log.Logger) error { return nil diff --git a/tests/bor/helper/miner.go b/tests/bor/helper/miner.go index eac225c4938..6a8e95563d3 100644 --- a/tests/bor/helper/miner.go +++ b/tests/bor/helper/miner.go @@ -78,16 +78,15 @@ func NewNodeConfig() *nodecfg.Config { } // InitNode initializes a node with the given genesis file and config -func InitMiner(ctx context.Context, genesis *types.Genesis, privKey *ecdsa.PrivateKey, withoutHeimdall bool, minerID int) (*node.Node, *eth.Ethereum, error) { +func InitMiner(ctx context.Context, dirName string, genesis *types.Genesis, privKey *ecdsa.PrivateKey, withoutHeimdall bool, minerID int) (*node.Node, *eth.Ethereum, error) { // Define the basic configurations for the Ethereum node - ddir, _ := os.MkdirTemp("", "") logger := log.New() nodeCfg := &nodecfg.Config{ Name: "erigon", Version: params.Version, - Dirs: datadir.New(ddir), + Dirs: datadir.New(dirName), P2P: p2p.Config{ ListenAddr: ":30303", ProtocolVersion: []uint{direct.ETH68, direct.ETH67}, // No need to specify direct.ETH66, because 1 sentry is used for both 66 and 67 @@ -125,13 +124,13 @@ func InitMiner(ctx context.Context, genesis *types.Genesis, privKey *ecdsa.Priva return nil, nil, err } - downloaderConfig, err := downloadercfg.New(datadir.New(ddir), nodeCfg.Version, torrentLogLevel, downloadRate, uploadRate, utils.TorrentPortFlag.Value, utils.TorrentConnsPerFileFlag.Value, utils.TorrentDownloadSlotsFlag.Value, []string{}, []string{}, "", true, utils.DbWriteMapFlag.Value) + downloaderConfig, err := downloadercfg.New(datadir.New(dirName), nodeCfg.Version, torrentLogLevel, downloadRate, uploadRate, utils.TorrentPortFlag.Value, utils.TorrentConnsPerFileFlag.Value, utils.TorrentDownloadSlotsFlag.Value, []string{}, []string{}, "", true, utils.DbWriteMapFlag.Value) if err != nil { return nil, nil, err } ethCfg := ðconfig.Config{ - Dirs: datadir.New(ddir), + Dirs: datadir.New(dirName), Genesis: genesis, NetworkID: genesis.Config.ChainID.Uint64(), TxPool: txpoolcfg.DefaultConfig, diff --git a/tests/bor/mining_test.go b/tests/bor/mining_test.go index c52d677890d..93067922b1e 100644 --- a/tests/bor/mining_test.go +++ b/tests/bor/mining_test.go @@ -71,7 +71,7 @@ func TestMiningBenchmark(t *testing.T) { var txs []*types.Transaction for i := 0; i < 1; i++ { - stack, ethBackend, err := helper.InitMiner(context.Background(), &genesis, pkeys[i], true, i) + stack, ethBackend, err := helper.InitMiner(context.Background(), t.TempDir(), &genesis, pkeys[i], true, i) if err != nil { panic(err) } @@ -120,11 +120,10 @@ func TestMiningBenchmark(t *testing.T) { if err != nil { panic(err) } - resp, err := ethbackends[0].TxpoolServer().Add(context.Background(), &txpool.AddRequest{RlpTxs: [][]byte{buf.Bytes()}}) + _, err = ethbackends[0].TxpoolServer().Add(context.Background(), &txpool.AddRequest{RlpTxs: [][]byte{buf.Bytes()}}) if err != nil { panic(err) } - println(fmt.Sprintf("%+v", resp)) } for { @@ -132,7 +131,6 @@ func TestMiningBenchmark(t *testing.T) { if err != nil { panic(err) } - if pendingReply.PendingCount == 0 { break } From cb85cfda363693bc6f39814b5824e9975597f594 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Mon, 29 Jul 2024 11:20:55 +0300 Subject: [PATCH 07/53] save --- cmd/integration/commands/state_stages.go | 13 ++++++++++--- eth/stagedsync/stage_mining_create_block.go | 19 +++++++++---------- eth/stagedsync/stagebuilder.go | 2 +- 3 files changed, 20 insertions(+), 14 deletions(-) diff --git a/cmd/integration/commands/state_stages.go b/cmd/integration/commands/state_stages.go index b5baf7b3efe..def2101d94c 100644 --- a/cmd/integration/commands/state_stages.go +++ b/cmd/integration/commands/state_stages.go @@ -22,6 +22,7 @@ import ( "encoding/json" "errors" "fmt" + stateLib "github.com/erigontech/erigon-lib/state" "os" "time" @@ -165,6 +166,12 @@ func syncBySmallSteps(db kv.RwDB, miningConfig params.MiningConfig, ctx context. } defer tx.Rollback() + sd, err := stateLib.NewSharedDomains(tx, logger1) + if err != nil { + return err + } + defer sd.Close() + quit := ctx.Done() var batchSize datasize.ByteSize @@ -270,7 +277,7 @@ func syncBySmallSteps(db kv.RwDB, miningConfig params.MiningConfig, ctx context. stateStages.MockExecFunc(stages.Execution, execUntilFunc(execToBlock)) _ = stateStages.SetCurrentStage(stages.Execution) - if _, err := stateStages.Run(db, wrap.TxContainer{Tx: tx}, false /* firstCycle */, false); err != nil { + if _, err := stateStages.Run(db, wrap.TxContainer{Tx: tx, Doms: sd}, false /* firstCycle */, false); err != nil { return err } @@ -300,7 +307,7 @@ func syncBySmallSteps(db kv.RwDB, miningConfig params.MiningConfig, ctx context. miner.MiningConfig.Etherbase = nextBlock.Coinbase() miner.MiningConfig.ExtraData = nextBlock.Extra() miningStages.MockExecFunc(stages.MiningCreateBlock, func(badBlockUnwind bool, s *stagedsync.StageState, u stagedsync.Unwinder, txc wrap.TxContainer, logger log.Logger) error { - err = stagedsync.SpawnMiningCreateBlockStage(s, txc.Ttx, + err = stagedsync.SpawnMiningCreateBlockStage(s, txc, stagedsync.StageMiningCreateBlockCfg(db, miner, *chainConfig, engine, nil, nil, dirs.Tmp, br), quit, logger) if err != nil { @@ -322,7 +329,7 @@ func syncBySmallSteps(db kv.RwDB, miningConfig params.MiningConfig, ctx context. //}) _ = miningStages.SetCurrentStage(stages.MiningCreateBlock) - if _, err := miningStages.Run(db, wrap.TxContainer{Tx: tx}, false /* firstCycle */, false); err != nil { + if _, err := miningStages.Run(db, wrap.TxContainer{Tx: tx, Doms: sd}, false /* firstCycle */, false); err != nil { return err } tx.Rollback() diff --git a/eth/stagedsync/stage_mining_create_block.go b/eth/stagedsync/stage_mining_create_block.go index 7dce179981b..28d79234d90 100644 --- a/eth/stagedsync/stage_mining_create_block.go +++ b/eth/stagedsync/stage_mining_create_block.go @@ -20,6 +20,7 @@ import ( "context" "errors" "fmt" + "github.com/erigontech/erigon-lib/wrap" "math/big" "time" @@ -108,7 +109,7 @@ var maxTransactions uint16 = 1000 // SpawnMiningCreateBlockStage // TODO: // - resubmitAdjustCh - variable is not implemented -func SpawnMiningCreateBlockStage(s *StageState, tx kv.TemporalTx, cfg MiningCreateBlockCfg, quit <-chan struct{}, logger log.Logger) (err error) { +func SpawnMiningCreateBlockStage(s *StageState, txc wrap.TxContainer, cfg MiningCreateBlockCfg, quit <-chan struct{}, logger log.Logger) (err error) { current := cfg.miner.MiningBlock txPoolLocals := []libcommon.Address{} //txPoolV2 has no concept of local addresses (yet?) coinbase := cfg.miner.MiningConfig.Etherbase @@ -119,11 +120,11 @@ func SpawnMiningCreateBlockStage(s *StageState, tx kv.TemporalTx, cfg MiningCrea ) logPrefix := s.LogPrefix() - executionAt, err := s.ExecutionAt(tx) + executionAt, err := s.ExecutionAt(txc.Tx) if err != nil { return fmt.Errorf("getting last executed block: %w", err) } - parent := rawdb.ReadHeaderByNumber(tx, executionAt) + parent := rawdb.ReadHeaderByNumber(txc.Tx, executionAt) if parent == nil { // todo: how to return error and don't stop Erigon? return fmt.Errorf("empty block %d", executionAt) } @@ -142,18 +143,18 @@ func SpawnMiningCreateBlockStage(s *StageState, tx kv.TemporalTx, cfg MiningCrea blockNum := executionAt + 1 - localUncles, remoteUncles, err := readNonCanonicalHeaders(tx, blockNum, cfg.engine, coinbase, txPoolLocals) + localUncles, remoteUncles, err := readNonCanonicalHeaders(txc.Tx, blockNum, cfg.engine, coinbase, txPoolLocals) if err != nil { return err } - chain := ChainReader{Cfg: cfg.chainConfig, Db: tx, BlockReader: cfg.blockReader, Logger: logger} + chain := ChainReader{Cfg: cfg.chainConfig, Db: txc.Tx, BlockReader: cfg.blockReader, Logger: logger} var GetBlocksFromHash = func(hash libcommon.Hash, n int) (blocks []*types.Block) { - number := rawdb.ReadHeaderNumber(tx, hash) + number := rawdb.ReadHeaderNumber(txc.Tx, hash) if number == nil { return nil } for i := 0; i < n; i++ { - block, _, _ := cfg.blockReader.BlockWithSenders(context.Background(), tx, hash, *number) + block, _, _ := cfg.blockReader.BlockWithSenders(context.Background(), txc.Tx, hash, *number) if block == nil { break } @@ -194,9 +195,7 @@ func SpawnMiningCreateBlockStage(s *StageState, tx kv.TemporalTx, cfg MiningCrea header.Extra = cfg.miner.MiningConfig.ExtraData logger.Info(fmt.Sprintf("[%s] Start mine", logPrefix), "block", executionAt+1, "baseFee", header.BaseFee, "gasLimit", header.GasLimit) - - stateReader := state.NewPlainStateReader(tx) - ibs := state.New(stateReader) + ibs := state.New(state.NewReaderV4(txc.Doms)) if err = cfg.engine.Prepare(chain, header, ibs); err != nil { logger.Error("Failed to prepare header for mining", diff --git a/eth/stagedsync/stagebuilder.go b/eth/stagedsync/stagebuilder.go index d72c314d6db..7bbe9e83137 100644 --- a/eth/stagedsync/stagebuilder.go +++ b/eth/stagedsync/stagebuilder.go @@ -49,7 +49,7 @@ func MiningStages( ID: stages.MiningCreateBlock, Description: "Mining: construct new block from txn pool", Forward: func(badBlockUnwind bool, s *StageState, u Unwinder, txc wrap.TxContainer, logger log.Logger) error { - return SpawnMiningCreateBlockStage(s, txc.Ttx, createBlockCfg, ctx.Done(), logger) + return SpawnMiningCreateBlockStage(s, txc, createBlockCfg, ctx.Done(), logger) }, Unwind: func(u *UnwindState, s *StageState, txc wrap.TxContainer, logger log.Logger) error { return nil From 64efcd7d68d06d679912a80802ee4d6a38ef07df Mon Sep 17 00:00:00 2001 From: JkLondon Date: Tue, 30 Jul 2024 15:52:28 +0300 Subject: [PATCH 08/53] more logging --- erigon-lib/txpool/fetch.go | 1 + tests/bor/mining_test.go | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/erigon-lib/txpool/fetch.go b/erigon-lib/txpool/fetch.go index adc8fe5fd6f..2a2ccd3fbdd 100644 --- a/erigon-lib/txpool/fetch.go +++ b/erigon-lib/txpool/fetch.go @@ -475,6 +475,7 @@ func (f *Fetch) handleStateChanges(ctx context.Context, client StateChangesClien func (f *Fetch) handleStateChangesRequest(ctx context.Context, req *remote.StateChangeBatch) error { var unwindTxs, unwindBlobTxs, minedTxs types2.TxSlots + f.logger.Error("[txpool.fetch] state changes") for _, change := range req.ChangeBatch { if change.Direction == remote.Direction_FORWARD { minedTxs.Resize(uint(len(change.Txs))) diff --git a/tests/bor/mining_test.go b/tests/bor/mining_test.go index 93067922b1e..0a56651c04d 100644 --- a/tests/bor/mining_test.go +++ b/tests/bor/mining_test.go @@ -59,7 +59,7 @@ func TestMiningBenchmark(t *testing.T) { // t.Skip("TODO: [e4] implement me") //} - log.Root().SetHandler(log.LvlFilterHandler(log.LvlWarn, log.StreamHandler(os.Stderr, log.TerminalFormat()))) + log.Root().SetHandler(log.LvlFilterHandler(log.LvlDebug, log.StreamHandler(os.Stderr, log.TerminalFormat()))) fdlimit.Raise(2048) genesis := helper.InitGenesis("./testdata/genesis_2val.json", 64, networkname.BorE2ETestChain2ValName) From 50895bd0274655d946aa97addffc0af717e781be Mon Sep 17 00:00:00 2001 From: JkLondon Date: Tue, 30 Jul 2024 16:42:48 +0300 Subject: [PATCH 09/53] more logging --- eth/backend.go | 1 + 1 file changed, 1 insertion(+) diff --git a/eth/backend.go b/eth/backend.go index dd302f4c5ea..370db30e3d5 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -793,6 +793,7 @@ func New(ctx context.Context, stack *node.Node, config *ethconfig.Config, logger // 2) we cannot propose for block 1 regardless. if !config.DeprecatedTxPool.Disable { + println("connected to backend core") backend.txPoolFetch.ConnectCore() backend.txPoolFetch.ConnectSentries() var newTxsBroadcaster *txpool.NewSlotsStreams From ef03b6e9cfe74d39ab3e6fc9711ebd9b5263a6d7 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Tue, 30 Jul 2024 18:10:17 +0300 Subject: [PATCH 10/53] more logging --- eth/backend.go | 2 ++ p2p/sentry/sentry_multi_client/broadcast.go | 1 + 2 files changed, 3 insertions(+) diff --git a/eth/backend.go b/eth/backend.go index 370db30e3d5..1de6024049b 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -456,6 +456,7 @@ func New(ctx context.Context, stack *node.Node, config *ethconfig.Config, logger var pi int // points to next port to be picked from refCfg.AllowedPorts for _, protocol := range p2pConfig.ProtocolVersion { + logger.Error("in sentry:", "protocol", protocol) cfg := p2pConfig cfg.NodeDatabase = filepath.Join(stack.Config().Dirs.Nodes, eth.ProtocolToString[protocol]) @@ -1309,6 +1310,7 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient } if !working && hasWork { + s.logger.Error("Started working") working = true hasWork = false mineEvery.Reset(miner.MiningConfig.Recommit) diff --git a/p2p/sentry/sentry_multi_client/broadcast.go b/p2p/sentry/sentry_multi_client/broadcast.go index 702f8d2f84f..62d87e85543 100644 --- a/p2p/sentry/sentry_multi_client/broadcast.go +++ b/p2p/sentry/sentry_multi_client/broadcast.go @@ -63,6 +63,7 @@ func (cs *MultiClient) PropagateNewBlockHashes(ctx context.Context, announces [] if err != nil { log.Error("propagateNewBlockHashes", "err", err) } + cs.logger.Error("sended msg") } } From 924cf67ef3c02f37ca724637d60c3a25cf05bfff Mon Sep 17 00:00:00 2001 From: JkLondon Date: Wed, 31 Jul 2024 20:58:44 +0300 Subject: [PATCH 11/53] more logging --- eth/backend.go | 1 + eth/stagedsync/exec3.go | 5 +++ eth/stagedsync/stage_headers.go | 5 ++- turbo/stages/headerdownload/header_algos.go | 3 ++ turbo/stages/stageloop.go | 38 +++++++++++++++++++-- 5 files changed, 48 insertions(+), 4 deletions(-) diff --git a/eth/backend.go b/eth/backend.go index b6c015b208b..0e49116160d 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -820,6 +820,7 @@ func New(ctx context.Context, stack *node.Node, config *ethconfig.Config, logger // will trigger the staged sync which will require headers and blocks to be available // in their respective cache in the download stage. If not found, it would cause a // liveness issue for the chain. + logger.Error("mined", "header", b.Header().Number.String()) if err := backend.sentriesClient.Hd.AddMinedHeader(b.Header()); err != nil { logger.Error("add mined block to header downloader", "err", err) } diff --git a/eth/stagedsync/exec3.go b/eth/stagedsync/exec3.go index 61a1220ce4a..40a708576e9 100644 --- a/eth/stagedsync/exec3.go +++ b/eth/stagedsync/exec3.go @@ -1074,6 +1074,11 @@ func flushAndCheckCommitmentV3(ctx context.Context, header *types.Header, applyT return false, fmt.Errorf("writing plain state version: %w", err) } } + + if header == nil { + return false, fmt.Errorf("header is nil") + } + if dbg.DiscardCommitment() { return true, nil } diff --git a/eth/stagedsync/stage_headers.go b/eth/stagedsync/stage_headers.go index fa5b69854ed..0c512851caa 100644 --- a/eth/stagedsync/stage_headers.go +++ b/eth/stagedsync/stage_headers.go @@ -162,7 +162,7 @@ func HeadersPOW(s *StageState, u Unwinder, ctx context.Context, tx kv.RwTx, cfg return nil } - logger.Info(fmt.Sprintf("[%s] Waiting for headers...", logPrefix), "from", startProgress) + logger.Info(fmt.Sprintf("[%s] Waiting for headers...", logPrefix), "from", startProgress, "hash", hash.Hex()) diagnostics.Send(diagnostics.HeadersWaitingUpdate{From: startProgress}) @@ -175,6 +175,9 @@ func HeadersPOW(s *StageState, u Unwinder, ctx context.Context, tx kv.RwTx, cfg return fmt.Errorf("localTD is nil: %d, %x", startProgress, hash) } TEMP TESTING */ + if localTd == nil { + logger.Error("localTD is nil", "startProgress", startProgress, "hash", hash) + } headerInserter := headerdownload.NewHeaderInserter(logPrefix, localTd, startProgress, cfg.blockReader) cfg.hd.SetHeaderReader(&ChainReaderImpl{ config: &cfg.chainConfig, diff --git a/turbo/stages/headerdownload/header_algos.go b/turbo/stages/headerdownload/header_algos.go index 8cd2aa3a8fa..ecd6d14b70b 100644 --- a/turbo/stages/headerdownload/header_algos.go +++ b/turbo/stages/headerdownload/header_algos.go @@ -392,7 +392,10 @@ func (hd *HeaderDownload) RequestMoreHeaders(currentTime time.Time) (*HeaderRequ defer hd.lock.Unlock() var penalties []PenaltyItem var req *HeaderRequest + hd.logger.Error("[downloader] RequestMoreHeaders", "currentTime", currentTime) + hd.anchorTree.Ascend(func(anchor *Anchor) bool { + hd.logger.Error("in request more", "anch hash", anchor.parentHash.Hex()) if anchor.blockHeight == 0 { //has no parent return true } diff --git a/turbo/stages/stageloop.go b/turbo/stages/stageloop.go index 2c51436acdc..96684302d33 100644 --- a/turbo/stages/stageloop.go +++ b/turbo/stages/stageloop.go @@ -72,10 +72,11 @@ func StageLoop( hook *Hook, ) { defer close(waitForDone) - + logger.Error("stageLoop start") if err := ProcessFrozenBlocks(ctx, db, blockReader, sync); err != nil { if err != nil { if errors.Is(err, libcommon.ErrStopped) || errors.Is(err, context.Canceled) { + println("what") return } @@ -86,6 +87,20 @@ func StageLoop( } } + //tx, err := db.BeginRw(ctx) + //if err != nil { + // logger.Error("BeginRw err", "err", err) + // return + //} + //defer tx.Rollback() + // + //sd, err := state.NewSharedDomains(tx, logger) + //if err != nil { + // logger.Error("NewSharedDomains err", "err", err) + // return + //} + //defer sd.Close() + initialCycle := true for { start := time.Now() @@ -99,7 +114,8 @@ func StageLoop( t := time.Now() // Estimate the current top height seen from the peer - err := StageLoopIteration(ctx, db, wrap.TxContainer{}, sync, initialCycle, false, logger, blockReader, hook) + + err := StageLoopIteration(ctx, db, wrap.TxContainer{ /*Tx: tx, Doms: sd*/ }, sync, initialCycle, false, logger, blockReader, hook) if err != nil { if errors.Is(err, libcommon.ErrStopped) || errors.Is(err, context.Canceled) { return @@ -178,11 +194,13 @@ func ProcessFrozenBlocks(ctx context.Context, db kv.RwDB, blockReader services.F func StageLoopIteration(ctx context.Context, db kv.RwDB, txc wrap.TxContainer, sync *stagedsync.Sync, initialCycle, firstCycle bool, logger log.Logger, blockReader services.FullBlockReader, hook *Hook) (err error) { defer func() { if rec := recover(); rec != nil { + logger.Error("panic", "err", dbg.Stack()) err = fmt.Errorf("%+v, trace: %s", rec, dbg.Stack()) } }() // avoid crash because Erigon's core does many things externalTx := txc.Tx != nil + println("externalTx", externalTx) finishProgressBefore, borProgressBefore, headersProgressBefore, err := stagesHeadersAndFinish(db, txc.Tx) if err != nil { return err @@ -218,17 +236,27 @@ func StageLoopIteration(ctx context.Context, db kv.RwDB, txc wrap.TxContainer, s return err } defer txc.Tx.Rollback() + txc.Doms, err = state.NewSharedDomains(txc.Tx, logger) + if err != nil { + logger.Error("NewSharedDomains err", "err", err) + return err + } + defer txc.Doms.Close() } if hook != nil { if err = hook.BeforeRun(txc.Tx, isSynced); err != nil { + logger.Error("BeforeRun err", "err", err) return err } + logger.Error("BeforeRun hook", "hook", hook.chainConfig.ChainID.String()) } + logger.Error("start sync") _, err = sync.Run(db, txc, initialCycle, firstCycle) if err != nil { return err } + logger.Error("finish sync") logCtx := sync.PrintTimings() //var tableSizes []interface{} var commitTime time.Duration @@ -240,10 +268,12 @@ func StageLoopIteration(ctx context.Context, db kv.RwDB, txc wrap.TxContainer, s if errTx != nil { return errTx } + txc.Doms = nil commitTime = time.Since(commitStart) } // -- send notifications START + logger.Error("trying to after run", "hook nil?", hook == nil) if hook != nil { if err = hook.AfterRun(txc.Tx, finishProgressBefore); err != nil { return err @@ -345,6 +375,7 @@ func (h *Hook) AfterRun(tx kv.Tx, finishProgressBefore uint64) error { } func (h *Hook) afterRun(tx kv.Tx, finishProgressBefore uint64) error { // Update sentry status for peers to see our sync status + h.logger.Error("after run", "finishProgressBefore", finishProgressBefore) if h.updateHead != nil { h.updateHead(h.ctx) } @@ -356,6 +387,7 @@ func (h *Hook) afterRun(tx kv.Tx, finishProgressBefore uint64) error { func (h *Hook) sendNotifications(notifications *shards.Notifications, tx kv.Tx, finishProgressBefore uint64) error { // update the accumulator with a new plain state version so the cache can be notified that // state has moved on + h.logger.Error("starting to send") if notifications.Accumulator != nil { plainStateVersion, err := rawdb.GetStateVersion(tx) if err != nil { @@ -397,7 +429,7 @@ func (h *Hook) sendNotifications(notifications *shards.Notifications, tx kv.Tx, finalizedBlock = *fb } - //h.logger.Debug("[hook] Sending state changes", "currentBlock", currentHeader.Number.Uint64(), "finalizedBlock", finalizedBlock) + h.logger.Error("[hook] Sending state changes", "currentBlock", currentHeader.Number.Uint64(), "finalizedBlock", finalizedBlock) notifications.Accumulator.SendAndReset(h.ctx, notifications.StateChangesConsumer, pendingBaseFee.Uint64(), pendingBlobFee, currentHeader.GasLimit, finalizedBlock) } return nil From 47b6089f81861dc295d4ba8010d05e8051448e0e Mon Sep 17 00:00:00 2001 From: JkLondon Date: Thu, 1 Aug 2024 15:38:51 +0300 Subject: [PATCH 12/53] more logging --- eth/stagedsync/sync.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/eth/stagedsync/sync.go b/eth/stagedsync/sync.go index 83541f975a0..3dc3d8c8db8 100644 --- a/eth/stagedsync/sync.go +++ b/eth/stagedsync/sync.go @@ -409,7 +409,7 @@ func (s *Sync) Run(db kv.RwDB, txc wrap.TxContainer, initialCycle, firstCycle bo s.NextStage() continue } - + s.logger.Error("current stage now is", "stage", stage.ID, "description", stage.DisabledDescription) if err := s.runStage(stage, db, txc, initialCycle, firstCycle, badBlockUnwind); err != nil { return false, err } From b3757678216dc153f8266109057d5b9423119a78 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Thu, 1 Aug 2024 16:15:32 +0300 Subject: [PATCH 13/53] more logging --- eth/stagedsync/stage_mining_create_block.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/eth/stagedsync/stage_mining_create_block.go b/eth/stagedsync/stage_mining_create_block.go index 614b7f62994..d575b8dd506 100644 --- a/eth/stagedsync/stage_mining_create_block.go +++ b/eth/stagedsync/stage_mining_create_block.go @@ -140,7 +140,7 @@ func SpawnMiningCreateBlockStage(s *StageState, txc wrap.TxContainer, cfg Mining // If we do not have an etherbase, let's use the suggested one coinbase = cfg.blockBuilderParameters.SuggestedFeeRecipient } - + logger.Error("in mining create", "last execution at", executionAt) blockNum := executionAt + 1 localUncles, remoteUncles, err := readNonCanonicalHeaders(txc.Tx, blockNum, cfg.engine, coinbase, txPoolLocals) From 3c5d9bdb525efc8e0eff53accedebec478e491e3 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Thu, 1 Aug 2024 16:36:57 +0300 Subject: [PATCH 14/53] more logging --- eth/backend.go | 4 +++- eth/stagedsync/sync.go | 1 + turbo/stages/stageloop.go | 1 - 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/eth/backend.go b/eth/backend.go index 0e49116160d..aafd4826425 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -1253,6 +1253,7 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient defer streamCancel() mineEvery := time.NewTicker(miner.MiningConfig.Recommit) + s.logger.Error("mine every loop", "every", miner.MiningConfig.Recommit.Seconds()) defer mineEvery.Stop() s.logger.Info("Starting to mine", "etherbase", eb) @@ -1308,13 +1309,14 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient return } } - + s.logger.Error("in loop of mining", "working", working, "hasWork", hasWork) if !working && hasWork { s.logger.Error("Started working") working = true hasWork = false mineEvery.Reset(miner.MiningConfig.Recommit) go func() { + s.logger.Error("come from goroutine in StartMining") err := stages2.MiningStep(ctx, db, mining, tmpDir, logger) waiting.Store(true) diff --git a/eth/stagedsync/sync.go b/eth/stagedsync/sync.go index 3dc3d8c8db8..7acc45d8df4 100644 --- a/eth/stagedsync/sync.go +++ b/eth/stagedsync/sync.go @@ -444,6 +444,7 @@ func (s *Sync) Run(db kv.RwDB, txc wrap.TxContainer, initialCycle, firstCycle bo s.NextStage() } + s.logger.Error("MINING IS OVER!!!!") if err := s.SetCurrentStage(s.stages[0].ID); err != nil { return false, err diff --git a/turbo/stages/stageloop.go b/turbo/stages/stageloop.go index 96684302d33..e88cb149fa1 100644 --- a/turbo/stages/stageloop.go +++ b/turbo/stages/stageloop.go @@ -465,7 +465,6 @@ func MiningStep(ctx context.Context, db kv.RwDB, mining *stagedsync.Sync, tmpDir if _, err = mining.Run(nil, txc, false /* firstCycle */, false); err != nil { return err } - tx.Rollback() return nil } From 81f024620afd86a3a68ade0cbafd7401a9b3fd9b Mon Sep 17 00:00:00 2001 From: JkLondon Date: Fri, 2 Aug 2024 13:13:27 +0400 Subject: [PATCH 15/53] more logging --- turbo/shards/state_change_accumulator.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/turbo/shards/state_change_accumulator.go b/turbo/shards/state_change_accumulator.go index 1e0e57a3cbf..12cd57a921a 100644 --- a/turbo/shards/state_change_accumulator.go +++ b/turbo/shards/state_change_accumulator.go @@ -54,6 +54,11 @@ func (a *Accumulator) SendAndReset(ctx context.Context, c StateChangeConsumer, p return } sc := &remote.StateChangeBatch{StateVersionId: a.plainStateID, ChangeBatch: a.changes, PendingBlockBaseFee: pendingBaseFee, BlockGasLimit: blockGasLimit, FinalizedBlock: finalizedBlock, PendingBlobFeePerGas: pendingBlobFee} + println("reseting") + for _, change := range a.changes { + println("txs", len(change.Txs)) + } + println("---------------------------------------------") c.SendStateChanges(ctx, sc) a.Reset(0) // reset here for GC, but there will be another Reset with correct viewID } From 4ff526a122b5b5878edbd0dfe047736398aad924 Mon Sep 17 00:00:00 2001 From: "alex.sharov" Date: Fri, 2 Aug 2024 16:44:53 +0700 Subject: [PATCH 16/53] save --- eth/stagedsync/stage_mining_exec.go | 1 + turbo/shards/state_change_accumulator.go | 2 ++ 2 files changed, 3 insertions(+) diff --git a/eth/stagedsync/stage_mining_exec.go b/eth/stagedsync/stage_mining_exec.go index 2f30c4a6152..90419491d60 100644 --- a/eth/stagedsync/stage_mining_exec.go +++ b/eth/stagedsync/stage_mining_exec.go @@ -280,6 +280,7 @@ func getNextTransactions( return err } + log.Warn("[dbg] YieldBest", "executionAt", executionAt, "count", count) return nil }); err != nil { return nil, 0, err diff --git a/turbo/shards/state_change_accumulator.go b/turbo/shards/state_change_accumulator.go index 12cd57a921a..8bd48291bfe 100644 --- a/turbo/shards/state_change_accumulator.go +++ b/turbo/shards/state_change_accumulator.go @@ -22,6 +22,7 @@ import ( libcommon "github.com/erigontech/erigon-lib/common" "github.com/erigontech/erigon-lib/gointerfaces" remote "github.com/erigontech/erigon-lib/gointerfaces/remoteproto" + "github.com/erigontech/erigon-lib/log/v3" ) // Accumulator collects state changes in a form that can then be delivered to the RPC daemon @@ -69,6 +70,7 @@ func (a *Accumulator) SetStateID(stateID uint64) { // StartChange begins accumulation of changes for a new block func (a *Accumulator) StartChange(blockHeight uint64, blockHash libcommon.Hash, txs [][]byte, unwind bool) { + log.Warn("[dbg] StartChange", "blockHeight", blockHeight, "txs", len(txs)) a.changes = append(a.changes, &remote.StateChange{}) a.latestChange = a.changes[len(a.changes)-1] a.latestChange.BlockHeight = blockHeight From 075f097bff00c732183408962b8eb99580f20d12 Mon Sep 17 00:00:00 2001 From: "alex.sharov" Date: Fri, 2 Aug 2024 17:11:28 +0700 Subject: [PATCH 17/53] save --- eth/backend.go | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/eth/backend.go b/eth/backend.go index aafd4826425..175001b7986 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -1279,6 +1279,7 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient if working || !hasWork { select { case stateChanges := <-stateChangeCh: + log.Warn("[dbg] stateChangeCh") block := stateChanges.BlockHeight s.logger.Debug("Start mining based on previous block", "block", block) // TODO - can do mining clean up here as we have previous @@ -1286,17 +1287,22 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient hasWork = true case <-s.notifyMiningAboutNewTxs: + log.Warn("[dbg] notifyMiningAboutNewTxs") + // Skip mining based on new txn notif for bor consensus hasWork = s.chainConfig.Bor == nil if hasWork { s.logger.Debug("Start mining based on txpool notif") } case <-mineEvery.C: + log.Warn("[dbg] mineEvery") if !(working || waiting.Load()) { s.logger.Debug("Start mining based on miner.recommit", "duration", miner.MiningConfig.Recommit) } hasWork = !(working || waiting.Load()) case err := <-errc: + log.Warn("[dbg] errc", "err", err) + working = false hasWork = false if errors.Is(err, libcommon.ErrStopped) { From d205e43103075cf5f6caaf429bdf9b62a4e53b2c Mon Sep 17 00:00:00 2001 From: JkLondon Date: Fri, 2 Aug 2024 14:12:57 +0400 Subject: [PATCH 18/53] more logging --- eth/stagedsync/sync.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/eth/stagedsync/sync.go b/eth/stagedsync/sync.go index 7acc45d8df4..afdce53561a 100644 --- a/eth/stagedsync/sync.go +++ b/eth/stagedsync/sync.go @@ -409,7 +409,7 @@ func (s *Sync) Run(db kv.RwDB, txc wrap.TxContainer, initialCycle, firstCycle bo s.NextStage() continue } - s.logger.Error("current stage now is", "stage", stage.ID, "description", stage.DisabledDescription) + s.logger.Error("current stage now is", "stage", stage.ID, "stack", dbg.Stack()) if err := s.runStage(stage, db, txc, initialCycle, firstCycle, badBlockUnwind); err != nil { return false, err } From fa836eb3d46d52da13192254de8e69a9048ff3af Mon Sep 17 00:00:00 2001 From: JkLondon Date: Fri, 2 Aug 2024 14:27:58 +0400 Subject: [PATCH 19/53] added afterrun hook --- turbo/execution/eth1/ethereum_execution.go | 2 +- turbo/stages/stageloop.go | 26 ++++++++++++++++++++-- 2 files changed, 25 insertions(+), 3 deletions(-) diff --git a/turbo/execution/eth1/ethereum_execution.go b/turbo/execution/eth1/ethereum_execution.go index 26997319e2b..7c7675eacc4 100644 --- a/turbo/execution/eth1/ethereum_execution.go +++ b/turbo/execution/eth1/ethereum_execution.go @@ -327,7 +327,7 @@ func (e *EthereumExecutionModule) Start(ctx context.Context) { e.semaphore.Acquire(ctx, 1) defer e.semaphore.Release(1) - if err := stages.ProcessFrozenBlocks(ctx, e.db, e.blockReader, e.executionPipeline); err != nil { + if err := stages.ProcessFrozenBlocks(ctx, e.db, e.blockReader, e.executionPipeline, nil, false); err != nil { if !errors.Is(err, context.Canceled) { e.logger.Error("Could not start execution service", "err", err) } diff --git a/turbo/stages/stageloop.go b/turbo/stages/stageloop.go index e88cb149fa1..e5cb143917f 100644 --- a/turbo/stages/stageloop.go +++ b/turbo/stages/stageloop.go @@ -73,7 +73,7 @@ func StageLoop( ) { defer close(waitForDone) logger.Error("stageLoop start") - if err := ProcessFrozenBlocks(ctx, db, blockReader, sync); err != nil { + if err := ProcessFrozenBlocks(ctx, db, blockReader, sync, hook, false); err != nil { if err != nil { if errors.Is(err, libcommon.ErrStopped) || errors.Is(err, context.Canceled) { println("what") @@ -149,16 +149,38 @@ func StageLoop( } // ProcessFrozenBlocks - withuot global rwtx -func ProcessFrozenBlocks(ctx context.Context, db kv.RwDB, blockReader services.FullBlockReader, sync *stagedsync.Sync) error { +func ProcessFrozenBlocks(ctx context.Context, db kv.RwDB, blockReader services.FullBlockReader, sync *stagedsync.Sync, hook *Hook, inSync bool) error { sawZeroBlocksTimes := 0 initialCycle, firstCycle := true, true for { // run stages first time - it will download blocks + if hook != nil { + if err := db.View(ctx, func(tx kv.Tx) (err error) { + err = hook.BeforeRun(tx, inSync) + return err + }); err != nil { + return err + } + } + more, err := sync.Run(db, wrap.TxContainer{}, initialCycle, firstCycle) if err != nil { return err } + if hook != nil { + if err := db.View(ctx, func(tx kv.Tx) (err error) { + finishProgressBefore, _, _, err := stagesHeadersAndFinish(db, tx) + if err != nil { + return err + } + err = hook.AfterRun(tx, finishProgressBefore) + return err + }); err != nil { + return err + } + } + if err := sync.RunPrune(db, nil, initialCycle); err != nil { return err } From a72a4ae94bc75f8b671b9bbf1183090fc9aba37f Mon Sep 17 00:00:00 2001 From: JkLondon Date: Fri, 2 Aug 2024 14:51:02 +0400 Subject: [PATCH 20/53] added unwind --- eth/stagedsync/stage_mining_exec.go | 4 ++-- eth/stagedsync/stagebuilder.go | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/eth/stagedsync/stage_mining_exec.go b/eth/stagedsync/stage_mining_exec.go index 90419491d60..7571e6db349 100644 --- a/eth/stagedsync/stage_mining_exec.go +++ b/eth/stagedsync/stage_mining_exec.go @@ -96,7 +96,7 @@ func StageMiningExecCfg( // SpawnMiningExecStage // TODO: // - resubmitAdjustCh - variable is not implemented -func SpawnMiningExecStage(s *StageState, txc wrap.TxContainer, cfg MiningExecCfg, sendersCfg SendersCfg, execCfg ExecuteBlockCfg, ctx context.Context, logger log.Logger) error { +func SpawnMiningExecStage(s *StageState, txc wrap.TxContainer, cfg MiningExecCfg, sendersCfg SendersCfg, execCfg ExecuteBlockCfg, ctx context.Context, logger log.Logger, u Unwinder) error { cfg.vmConfig.NoReceipts = false chainID, _ := uint256.FromBig(cfg.chainConfig.ChainID) logPrefix := s.LogPrefix() @@ -239,7 +239,7 @@ func SpawnMiningExecStage(s *StageState, txc wrap.TxContainer, cfg MiningExecCfg // This flag will skip checking the state root execCfg.blockProduction = true execS := &StageState{state: s.state, ID: stages.Execution, BlockNumber: blockHeight - 1} - if err := ExecBlockV3(execS, nil, txc, blockHeight, context.Background(), execCfg, false, logger); err != nil { + if err := ExecBlockV3(execS, u, txc, blockHeight, context.Background(), execCfg, false, logger); err != nil { return err } diff --git a/eth/stagedsync/stagebuilder.go b/eth/stagedsync/stagebuilder.go index 7bbe9e83137..078ffe77b6b 100644 --- a/eth/stagedsync/stagebuilder.go +++ b/eth/stagedsync/stagebuilder.go @@ -76,7 +76,7 @@ func MiningStages( ID: stages.MiningExecution, Description: "Mining: execute new block from txn pool", Forward: func(badBlockUnwind bool, s *StageState, u Unwinder, txc wrap.TxContainer, logger log.Logger) error { - return SpawnMiningExecStage(s, txc, execCfg, sendersCfg, executeBlockCfg, ctx, logger) + return SpawnMiningExecStage(s, txc, execCfg, sendersCfg, executeBlockCfg, ctx, logger, u) }, Unwind: func(u *UnwindState, s *StageState, txc wrap.TxContainer, logger log.Logger) error { return nil From fe426e97ad8298f220cb95cdc3b28961c1657205 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Sat, 3 Aug 2024 00:06:50 +0400 Subject: [PATCH 21/53] argueble edit --- eth/backend.go | 19 +++++++++++++------ eth/stagedsync/stage_mining_exec.go | 17 +++++++++-------- eth/stagedsync/sync.go | 9 +++++++-- turbo/shards/state_change_accumulator.go | 3 ++- 4 files changed, 31 insertions(+), 17 deletions(-) diff --git a/eth/backend.go b/eth/backend.go index 175001b7986..dea35083b10 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -1251,8 +1251,10 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient defer debug.LogPanic() defer close(s.waitForMiningStop) defer streamCancel() - + //TODO: remove + miner.MiningConfig.Recommit = time.Second * 30 mineEvery := time.NewTicker(miner.MiningConfig.Recommit) + s.logger.Error("mine every loop", "every", miner.MiningConfig.Recommit.Seconds()) defer mineEvery.Stop() @@ -1287,7 +1289,7 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient hasWork = true case <-s.notifyMiningAboutNewTxs: - log.Warn("[dbg] notifyMiningAboutNewTxs") + //log.Warn("[dbg] notifyMiningAboutNewTxs") // Skip mining based on new txn notif for bor consensus hasWork = s.chainConfig.Bor == nil @@ -1295,7 +1297,7 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient s.logger.Debug("Start mining based on txpool notif") } case <-mineEvery.C: - log.Warn("[dbg] mineEvery") + log.Warn("[dbg] mineEvery", "working", working, "waiting", waiting.Load()) if !(working || waiting.Load()) { s.logger.Debug("Start mining based on miner.recommit", "duration", miner.MiningConfig.Recommit) } @@ -1315,7 +1317,9 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient return } } - s.logger.Error("in loop of mining", "working", working, "hasWork", hasWork) + if hasWork != false { + s.logger.Error("in loop of mining", "working", working, "hasWork", hasWork) + } if !working && hasWork { s.logger.Error("Started working") working = true @@ -1323,10 +1327,13 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient mineEvery.Reset(miner.MiningConfig.Recommit) go func() { s.logger.Error("come from goroutine in StartMining") - err := stages2.MiningStep(ctx, db, mining, tmpDir, logger) + err = stages2.MiningStep(ctx, db, mining, tmpDir, logger) waiting.Store(true) - defer waiting.Store(false) + defer func() { + s.logger.Error("out of mining", "err", err) + waiting.Store(false) + }() errc <- err diff --git a/eth/stagedsync/stage_mining_exec.go b/eth/stagedsync/stage_mining_exec.go index 7571e6db349..307caa9e897 100644 --- a/eth/stagedsync/stage_mining_exec.go +++ b/eth/stagedsync/stage_mining_exec.go @@ -208,38 +208,39 @@ func SpawnMiningExecStage(s *StageState, txc wrap.TxContainer, cfg MiningExecCfg current.Requests = block.Requests() // Simulate the block execution to get the final state root - if err := rawdb.WriteHeader(txc.Tx, block.Header()); err != nil { + if err = rawdb.WriteHeader(txc.Tx, block.Header()); err != nil { return fmt.Errorf("cannot write header: %s", err) } blockHeight := block.NumberU64() - if err := rawdb.WriteCanonicalHash(txc.Tx, block.Hash(), blockHeight); err != nil { + if err = rawdb.WriteCanonicalHash(txc.Tx, block.Hash(), blockHeight); err != nil { return fmt.Errorf("cannot write canonical hash: %s", err) } - if err := rawdb.WriteHeadHeaderHash(txc.Tx, block.Hash()); err != nil { + if err = rawdb.WriteHeadHeaderHash(txc.Tx, block.Hash()); err != nil { return err } if _, err = rawdb.WriteRawBodyIfNotExists(txc.Tx, block.Hash(), blockHeight, block.RawBody()); err != nil { return fmt.Errorf("cannot write body: %s", err) } - if err := rawdb.AppendCanonicalTxNums(txc.Tx, blockHeight); err != nil { + if err = rawdb.AppendCanonicalTxNums(txc.Tx, blockHeight); err != nil { return err } - if err := stages.SaveStageProgress(txc.Tx, kv.Headers, blockHeight); err != nil { + if err = stages.SaveStageProgress(txc.Tx, kv.Headers, blockHeight); err != nil { return err } - if err := stages.SaveStageProgress(txc.Tx, stages.Bodies, blockHeight); err != nil { + if err = stages.SaveStageProgress(txc.Tx, stages.Bodies, blockHeight); err != nil { return err } senderS := &StageState{state: s.state, ID: stages.Senders, BlockNumber: blockHeight - 1} - if err := SpawnRecoverSendersStage(sendersCfg, senderS, nil, txc.Tx, blockHeight, ctx, logger); err != nil { + if err = SpawnRecoverSendersStage(sendersCfg, senderS, nil, txc.Tx, blockHeight, ctx, logger); err != nil { return err } // This flag will skip checking the state root execCfg.blockProduction = true execS := &StageState{state: s.state, ID: stages.Execution, BlockNumber: blockHeight - 1} - if err := ExecBlockV3(execS, u, txc, blockHeight, context.Background(), execCfg, false, logger); err != nil { + if err = ExecBlockV3(execS, u, txc, blockHeight, context.Background(), execCfg, false, logger); err != nil { + logger.Error("cannot execute block execution", "err", err) return err } diff --git a/eth/stagedsync/sync.go b/eth/stagedsync/sync.go index afdce53561a..7b2b7577c6f 100644 --- a/eth/stagedsync/sync.go +++ b/eth/stagedsync/sync.go @@ -365,9 +365,8 @@ func (s *Sync) Run(db kv.RwDB, txc wrap.TxContainer, initialCycle, firstCycle bo s.timings = s.timings[:0] hasMore := false - + var badBlockUnwind bool for !s.IsDone() { - var badBlockUnwind bool if s.unwindPoint != nil { for j := 0; j < len(s.unwindOrder); j++ { if s.unwindOrder[j] == nil || s.unwindOrder[j].Disabled || s.unwindOrder[j].Unwind == nil { @@ -393,6 +392,7 @@ func (s *Sync) Run(db kv.RwDB, txc wrap.TxContainer, initialCycle, firstCycle bo if badBlockUnwind { // If there was a bad block, the current step needs to complete, to send the corresponding reply to the Consensus Layer // Otherwise, the staged sync will get stuck in the Headers stage with "Waiting for Consensus Layer..." + s.logger.Error("I've breaked here btw") break } @@ -451,6 +451,11 @@ func (s *Sync) Run(db kv.RwDB, txc wrap.TxContainer, initialCycle, firstCycle bo } s.currentStage = 0 + + if badBlockUnwind { + return false, errors.New("bad block unwinding") + } + return hasMore, nil } diff --git a/turbo/shards/state_change_accumulator.go b/turbo/shards/state_change_accumulator.go index 8bd48291bfe..9d3275d5b89 100644 --- a/turbo/shards/state_change_accumulator.go +++ b/turbo/shards/state_change_accumulator.go @@ -18,6 +18,7 @@ package shards import ( "context" + "github.com/erigontech/erigon-lib/common/dbg" libcommon "github.com/erigontech/erigon-lib/common" "github.com/erigontech/erigon-lib/gointerfaces" @@ -70,7 +71,7 @@ func (a *Accumulator) SetStateID(stateID uint64) { // StartChange begins accumulation of changes for a new block func (a *Accumulator) StartChange(blockHeight uint64, blockHash libcommon.Hash, txs [][]byte, unwind bool) { - log.Warn("[dbg] StartChange", "blockHeight", blockHeight, "txs", len(txs)) + log.Warn("[dbg] StartChange", "blockHeight", blockHeight, "txs", len(txs), "stack", dbg.Stack()) a.changes = append(a.changes, &remote.StateChange{}) a.latestChange = a.changes[len(a.changes)-1] a.latestChange.BlockHeight = blockHeight From 4ebc86e8e57b2ec1fabaf65f1753f66fc11eea4a Mon Sep 17 00:00:00 2001 From: JkLondon Date: Mon, 5 Aug 2024 11:54:37 +0400 Subject: [PATCH 22/53] more logging --- cmd/state/exec3/state.go | 6 ++++++ eth/stagedsync/exec3.go | 1 + 2 files changed, 7 insertions(+) diff --git a/cmd/state/exec3/state.go b/cmd/state/exec3/state.go index ef10170d759..8bcbd3daa63 100644 --- a/cmd/state/exec3/state.go +++ b/cmd/state/exec3/state.go @@ -18,6 +18,7 @@ package exec3 import ( "context" + "fmt" "sync" "golang.org/x/sync/errgroup" @@ -162,9 +163,13 @@ func (rw *Worker) RunTxTaskNoLock(txTask *state.TxTask) { // in case if we cancelled execution and commitment happened in the middle of the block, we have to process block // from the beginning until committed txNum and only then disable history mode. // Needed to correctly evaluate spent gas and other things. + println("history mode not enabled") rw.SetReader(state.NewHistoryReaderV3()) } else if !txTask.HistoryExecution && rw.historyMode { + println("history mode enabled") rw.SetReader(state.NewStateReaderV3(rw.rs.Domains())) + } else { + rw.logger.Error("RunTxTaskNoLock", "HistoryExecution", txTask.HistoryExecution, "HistoryMode", rw.historyMode, "reader", rw.stateReader) } if rw.background && rw.chainTx == nil { var err error @@ -175,6 +180,7 @@ func (rw *Worker) RunTxTaskNoLock(txTask *state.TxTask) { rw.stateWriter.SetTx(rw.chainTx) rw.chain = consensuschain.NewReader(rw.chainConfig, rw.chainTx, rw.blockReader, rw.logger) } + fmt.Printf("[dbg] in RunTxTaskNoLock %T\n", rw.chainTx) txTask.Error = nil rw.stateReader.SetTxNum(txTask.TxNum) diff --git a/eth/stagedsync/exec3.go b/eth/stagedsync/exec3.go index 40a708576e9..879d31dfa4b 100644 --- a/eth/stagedsync/exec3.go +++ b/eth/stagedsync/exec3.go @@ -830,6 +830,7 @@ Loop: return err } if errors.Is(err, consensus.ErrInvalidBlock) { + fmt.Printf("[dbg] in unwindTo %T/n", applyTx) if err := u.UnwindTo(blockNum-1, BadBlock(header.Hash(), err), applyTx); err != nil { return err } From 85725644e44847cc8ecee68046b968f7470eb58c Mon Sep 17 00:00:00 2001 From: "alex.sharov" Date: Tue, 6 Aug 2024 13:30:04 +0700 Subject: [PATCH 23/53] save --- .../kv/membatchwithdb/memory_mutation.go | 21 ++++++++++++------- erigon-lib/state/domain.go | 2 ++ eth/stagedsync/stage_mining_exec.go | 15 ++----------- 3 files changed, 18 insertions(+), 20 deletions(-) diff --git a/erigon-lib/kv/membatchwithdb/memory_mutation.go b/erigon-lib/kv/membatchwithdb/memory_mutation.go index 49d1c8d45e4..61f6ba656eb 100644 --- a/erigon-lib/kv/membatchwithdb/memory_mutation.go +++ b/erigon-lib/kv/membatchwithdb/memory_mutation.go @@ -731,28 +731,35 @@ func (m *MemoryMutation) AggTx() any { } func (m *MemoryMutation) DomainGet(name kv.Domain, k, k2 []byte) (v []byte, step uint64, err error) { - return m.db.(kv.TemporalTx).DomainGet(name, k, k2) + panic("not supported") + //return m.db.(kv.TemporalTx).DomainGet(name, k, k2) } func (m *MemoryMutation) DomainGetAsOf(name kv.Domain, k, k2 []byte, ts uint64) (v []byte, ok bool, err error) { - return m.db.(kv.TemporalTx).DomainGetAsOf(name, k, k2, ts) + panic("not supported") + //return m.db.(kv.TemporalTx).DomainGetAsOf(name, k, k2, ts) } func (m *MemoryMutation) HistorySeek(name kv.History, k []byte, ts uint64) (v []byte, ok bool, err error) { - return m.db.(kv.TemporalTx).HistorySeek(name, k, ts) + panic("not supported") + //return m.db.(kv.TemporalTx).HistorySeek(name, k, ts) } func (m *MemoryMutation) IndexRange(name kv.InvertedIdx, k []byte, fromTs, toTs int, asc order.By, limit int) (timestamps stream.U64, err error) { - return m.db.(kv.TemporalTx).IndexRange(name, k, fromTs, toTs, asc, limit) + panic("not supported") + //return m.db.(kv.TemporalTx).IndexRange(name, k, fromTs, toTs, asc, limit) } func (m *MemoryMutation) HistoryRange(name kv.History, fromTs, toTs int, asc order.By, limit int) (it stream.KV, err error) { - return m.db.(kv.TemporalTx).HistoryRange(name, fromTs, toTs, asc, limit) + panic("not supported") + //return m.db.(kv.TemporalTx).HistoryRange(name, fromTs, toTs, asc, limit) } func (m *MemoryMutation) DomainRange(name kv.Domain, fromKey, toKey []byte, ts uint64, asc order.By, limit int) (it stream.KV, err error) { - return m.db.(kv.TemporalTx).DomainRange(name, fromKey, toKey, ts, asc, limit) + panic("not supported") + //return m.db.(kv.TemporalTx).DomainRange(name, fromKey, toKey, ts, asc, limit) } func (m *MemoryMutation) AppendableGet(name kv.Appendable, ts kv.TxnId) ([]byte, bool, error) { - return m.db.(kv.TemporalTx).AppendableGet(name, ts) + panic("not supported") + //return m.db.(kv.TemporalTx).AppendableGet(name, ts) } diff --git a/erigon-lib/state/domain.go b/erigon-lib/state/domain.go index ce4964b8fe5..452ef305b8e 100644 --- a/erigon-lib/state/domain.go +++ b/erigon-lib/state/domain.go @@ -1316,6 +1316,8 @@ func (d *Domain) integrateDirtyFiles(sf StaticFiles, txNumFrom, txNumTo uint64) // unwind is similar to prune but the difference is that it restores domain values from the history as of txFrom // context Flush should be managed by caller. func (dt *DomainRoTx) Unwind(ctx context.Context, rwTx kv.RwTx, step, txNumUnwindTo uint64, domainDiffs []DomainEntryDiff) error { + fmt.Printf("[dbg] Unwind %T\n", rwTx) + // fmt.Printf("[domain][%s] unwinding domain to txNum=%d, step %d\n", d.filenameBase, txNumUnwindTo, step) d := dt.d diff --git a/eth/stagedsync/stage_mining_exec.go b/eth/stagedsync/stage_mining_exec.go index 307caa9e897..adbe1cb5b1d 100644 --- a/eth/stagedsync/stage_mining_exec.go +++ b/eth/stagedsync/stage_mining_exec.go @@ -28,9 +28,7 @@ import ( "github.com/holiman/uint256" "golang.org/x/net/context" - "github.com/erigontech/erigon-lib/kv/membatchwithdb" "github.com/erigontech/erigon-lib/log/v3" - state2 "github.com/erigontech/erigon-lib/state" "github.com/erigontech/erigon-lib/wrap" "github.com/erigontech/erigon-lib/chain" @@ -103,7 +101,6 @@ func SpawnMiningExecStage(s *StageState, txc wrap.TxContainer, cfg MiningExecCfg current := cfg.miningState.MiningBlock txs := current.PreparedTxs noempty := true - var domains *state2.SharedDomains var ( stateReader state.StateReader ) @@ -138,16 +135,8 @@ func SpawnMiningExecStage(s *StageState, txc wrap.TxContainer, cfg MiningExecCfg yielded := mapset.NewSet[[32]byte]() var simStateReader state.StateReader var simStateWriter state.StateWriter - m := membatchwithdb.NewMemoryBatch(txc.Tx, cfg.tmpdir, logger) - defer m.Rollback() - var err error - domains, err = state2.NewSharedDomains(m, logger) - if err != nil { - return err - } - defer domains.Close() - simStateReader = state.NewReaderV4(domains) - simStateWriter = state.NewWriterV4(domains) + simStateReader = state.NewReaderV4(txc.Doms) + simStateWriter = state.NewWriterV4(txc.Doms) executionAt, err := s.ExecutionAt(txc.Tx) if err != nil { From 25a3ce7ad4a9e16644553f052c12fa0e7775e496 Mon Sep 17 00:00:00 2001 From: "alex.sharov" Date: Tue, 6 Aug 2024 13:32:08 +0700 Subject: [PATCH 24/53] save --- erigon-lib/state/domain.go | 2 -- eth/stagedsync/stage_execute.go | 2 +- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/erigon-lib/state/domain.go b/erigon-lib/state/domain.go index 452ef305b8e..ce4964b8fe5 100644 --- a/erigon-lib/state/domain.go +++ b/erigon-lib/state/domain.go @@ -1316,8 +1316,6 @@ func (d *Domain) integrateDirtyFiles(sf StaticFiles, txNumFrom, txNumTo uint64) // unwind is similar to prune but the difference is that it restores domain values from the history as of txFrom // context Flush should be managed by caller. func (dt *DomainRoTx) Unwind(ctx context.Context, rwTx kv.RwTx, step, txNumUnwindTo uint64, domainDiffs []DomainEntryDiff) error { - fmt.Printf("[dbg] Unwind %T\n", rwTx) - // fmt.Printf("[domain][%s] unwinding domain to txNum=%d, step %d\n", d.filenameBase, txNumUnwindTo, step) d := dt.d diff --git a/eth/stagedsync/stage_execute.go b/eth/stagedsync/stage_execute.go index b4736fc9e25..0138db71698 100644 --- a/eth/stagedsync/stage_execute.go +++ b/eth/stagedsync/stage_execute.go @@ -305,7 +305,7 @@ func blocksReadAheadFunc(ctx context.Context, tx kv.Tx, cfg *ExecuteBlockCfg, bl } func UnwindExecutionStage(u *UnwindState, s *StageState, txc wrap.TxContainer, ctx context.Context, cfg ExecuteBlockCfg, logger log.Logger) (err error) { - //fmt.Printf("unwind: %d -> %d\n", u.CurrentBlockNumber, u.UnwindPoint) + fmt.Printf("unwind: %d -> %d, %T, %T\n", u.CurrentBlockNumber, u.UnwindPoint, txc.Tx, txc.Doms) if u.UnwindPoint >= s.BlockNumber { return nil } From 64deda3398ce983bc96f1b95c64752800c1b7ee4 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Wed, 7 Aug 2024 13:08:57 +0400 Subject: [PATCH 25/53] a lot of logging --- cmd/state/exec3/state.go | 26 +++++++++++++++++--------- core/state/intra_block_state.go | 21 +++++++++++++++++---- core/state/state_object.go | 5 ++++- core/state_processor.go | 3 ++- core/state_transition.go | 6 +++++- core/vm/evmtypes/evmtypes.go | 1 + eth/stagedsync/exec3.go | 27 ++++++++++++++++----------- eth/stagedsync/stage_execute.go | 6 +++--- eth/stagedsync/stage_mining_exec.go | 22 +++++++++++++++++++--- eth/stagedsync/stagebuilder.go | 2 +- 10 files changed, 85 insertions(+), 34 deletions(-) diff --git a/cmd/state/exec3/state.go b/cmd/state/exec3/state.go index 8bcbd3daa63..efd9981a378 100644 --- a/cmd/state/exec3/state.go +++ b/cmd/state/exec3/state.go @@ -70,9 +70,11 @@ type Worker struct { vmCfg vm.Config dirs datadir.Dirs + + isMining bool } -func NewWorker(lock sync.Locker, logger log.Logger, accumulator *shards.Accumulator, ctx context.Context, background bool, chainDb kv.RoDB, rs *state.StateV3, in *state.QueueWithRetry, blockReader services.FullBlockReader, chainConfig *chain.Config, genesis *types.Genesis, results *state.ResultsQueue, engine consensus.Engine, dirs datadir.Dirs) *Worker { +func NewWorker(lock sync.Locker, logger log.Logger, accumulator *shards.Accumulator, ctx context.Context, background bool, chainDb kv.RoDB, rs *state.StateV3, in *state.QueueWithRetry, blockReader services.FullBlockReader, chainConfig *chain.Config, genesis *types.Genesis, results *state.ResultsQueue, engine consensus.Engine, dirs datadir.Dirs, isMining bool) *Worker { w := &Worker{ lock: lock, logger: logger, @@ -95,6 +97,8 @@ func NewWorker(lock sync.Locker, logger log.Logger, accumulator *shards.Accumula taskGasPool: new(core.GasPool), dirs: dirs, + + isMining: isMining, } w.taskGasPool.AddBlobGas(chainConfig.GetMaxBlobGasPerBlock()) w.vmCfg = vm.Config{Debug: true, Tracer: w.callTracer} @@ -125,7 +129,7 @@ func (rw *Worker) ResetTx(chainTx kv.Tx) { func (rw *Worker) Run() error { for txTask, ok := rw.in.Next(rw.ctx); ok; txTask, ok = rw.in.Next(rw.ctx) { - rw.RunTxTask(txTask) + rw.RunTxTask(txTask, false) if err := rw.resultCh.Add(rw.ctx, txTask); err != nil { return err } @@ -133,10 +137,10 @@ func (rw *Worker) Run() error { return nil } -func (rw *Worker) RunTxTask(txTask *state.TxTask) { +func (rw *Worker) RunTxTask(txTask *state.TxTask, isMining bool) { rw.lock.Lock() defer rw.lock.Unlock() - rw.RunTxTaskNoLock(txTask) + rw.RunTxTaskNoLock(txTask, isMining) } // Needed to set history reader when need to offset few txs from block beginning and does not break processing, @@ -158,7 +162,7 @@ func (rw *Worker) SetReader(reader state.ResettableStateReader) { } } -func (rw *Worker) RunTxTaskNoLock(txTask *state.TxTask) { +func (rw *Worker) RunTxTaskNoLock(txTask *state.TxTask, isMining bool) { if txTask.HistoryExecution && !rw.historyMode { // in case if we cancelled execution and commitment happened in the middle of the block, we have to process block // from the beginning until committed txNum and only then disable history mode. @@ -229,7 +233,11 @@ func (rw *Worker) RunTxTaskNoLock(txTask *state.TxTask) { return core.SysCallContract(contract, data, rw.chainConfig, ibs, header, rw.engine, false /* constCall */) } - _, _, _, err := rw.engine.Finalize(rw.chainConfig, types.CopyHeader(header), ibs, txTask.Txs, txTask.Uncles, txTask.BlockReceipts, txTask.Withdrawals, txTask.Requests, rw.chain, syscall, rw.logger) + if isMining { + _, _, _, err = rw.engine.FinalizeAndAssemble(rw.chainConfig, types.CopyHeader(header), ibs, txTask.Txs, txTask.Uncles, txTask.BlockReceipts, txTask.Withdrawals, txTask.Requests, rw.chain, syscall, nil, rw.logger) + } else { + _, _, _, err = rw.engine.Finalize(rw.chainConfig, types.CopyHeader(header), ibs, txTask.Txs, txTask.Uncles, txTask.BlockReceipts, txTask.Withdrawals, txTask.Requests, rw.chain, syscall, rw.logger) + } if err != nil { txTask.Error = err } else { @@ -292,7 +300,7 @@ func (rw *Worker) RunTxTaskNoLock(txTask *state.TxTask) { } } -func NewWorkersPool(lock sync.Locker, accumulator *shards.Accumulator, logger log.Logger, ctx context.Context, background bool, chainDb kv.RoDB, rs *state.StateV3, in *state.QueueWithRetry, blockReader services.FullBlockReader, chainConfig *chain.Config, genesis *types.Genesis, engine consensus.Engine, workerCount int, dirs datadir.Dirs) (reconWorkers []*Worker, applyWorker *Worker, rws *state.ResultsQueue, clear func(), wait func()) { +func NewWorkersPool(lock sync.Locker, accumulator *shards.Accumulator, logger log.Logger, ctx context.Context, background bool, chainDb kv.RoDB, rs *state.StateV3, in *state.QueueWithRetry, blockReader services.FullBlockReader, chainConfig *chain.Config, genesis *types.Genesis, engine consensus.Engine, workerCount int, dirs datadir.Dirs, isMining bool) (reconWorkers []*Worker, applyWorker *Worker, rws *state.ResultsQueue, clear func(), wait func()) { reconWorkers = make([]*Worker, workerCount) resultChSize := workerCount * 8 @@ -303,7 +311,7 @@ func NewWorkersPool(lock sync.Locker, accumulator *shards.Accumulator, logger lo ctx, cancel := context.WithCancel(ctx) g, ctx := errgroup.WithContext(ctx) for i := 0; i < workerCount; i++ { - reconWorkers[i] = NewWorker(lock, logger, accumulator, ctx, background, chainDb, rs, in, blockReader, chainConfig, genesis, rws, engine, dirs) + reconWorkers[i] = NewWorker(lock, logger, accumulator, ctx, background, chainDb, rs, in, blockReader, chainConfig, genesis, rws, engine, dirs, isMining) } if background { for i := 0; i < workerCount; i++ { @@ -329,7 +337,7 @@ func NewWorkersPool(lock sync.Locker, accumulator *shards.Accumulator, logger lo //applyWorker.ResetTx(nil) } } - applyWorker = NewWorker(lock, logger, accumulator, ctx, false, chainDb, rs, in, blockReader, chainConfig, genesis, rws, engine, dirs) + applyWorker = NewWorker(lock, logger, accumulator, ctx, false, chainDb, rs, in, blockReader, chainConfig, genesis, rws, engine, dirs, isMining) return reconWorkers, applyWorker, rws, clear, wait } diff --git a/core/state/intra_block_state.go b/core/state/intra_block_state.go index 2b5cd6a8a18..a20a8e58588 100644 --- a/core/state/intra_block_state.go +++ b/core/state/intra_block_state.go @@ -23,12 +23,9 @@ package state import ( "errors" "fmt" - "sort" - - "github.com/holiman/uint256" - "github.com/erigontech/erigon-lib/chain" libcommon "github.com/erigontech/erigon-lib/common" + "github.com/erigontech/erigon-lib/common/dbg" types2 "github.com/erigontech/erigon-lib/types" "github.com/erigontech/erigon/common/u256" "github.com/erigontech/erigon/core/tracing" @@ -37,6 +34,8 @@ import ( "github.com/erigontech/erigon/core/vm/evmtypes" "github.com/erigontech/erigon/crypto" "github.com/erigontech/erigon/turbo/trie" + "github.com/holiman/uint256" + "sort" ) var _ evmtypes.IntraBlockState = new(IntraBlockState) // compile-time interface-check @@ -115,6 +114,14 @@ func New(stateReader StateReader) *IntraBlockState { } } +func (sdb *IntraBlockState) PrintNonceOfTestAddr() { + if obj, ok := sdb.stateObjects[libcommon.HexToAddress("0x71562b71999873DB5b286dF957af199Ec94617F7")]; !ok { + println("NO NONCE FOR TEST ADDRESS") + } else { + println("NONCE IS:", obj.Nonce()) + } +} + func (sdb *IntraBlockState) SetTrace(trace bool) { sdb.trace = trace } @@ -229,6 +236,9 @@ func (sdb *IntraBlockState) GetBalance(addr libcommon.Address) *uint256.Int { func (sdb *IntraBlockState) GetNonce(addr libcommon.Address) uint64 { stateObject := sdb.getStateObject(addr) if stateObject != nil && !stateObject.deleted { + if addr == libcommon.HexToAddress("0x71562b71999873DB5b286dF957af199Ec94617F7") && stateObject.Nonce() < 60 { + println("get nonce", stateObject.Nonce(), dbg.Stack()) + } return stateObject.Nonce() } @@ -508,10 +518,13 @@ func (sdb *IntraBlockState) getStateObject(addr libcommon.Address) (stateObject } return nil } + println("ACCOUNT NONCE IS", account.Nonce) // Insert into the live set. obj := newObject(sdb, addr, account, account) sdb.setStateObject(addr, obj) + println("IN THE END OF GET STATE OBJECT") + sdb.PrintNonceOfTestAddr() return obj } diff --git a/core/state/state_object.go b/core/state/state_object.go index 5df5b928964..7bba7741ade 100644 --- a/core/state/state_object.go +++ b/core/state/state_object.go @@ -22,6 +22,7 @@ package state import ( "bytes" "fmt" + "github.com/erigontech/erigon-lib/common/dbg" "io" "maps" "math/big" @@ -119,7 +120,6 @@ func newObject(db *IntraBlockState, address libcommon.Address, data, original *a so.data.Root = trie.EmptyRoot } so.original.Copy(original) - return &so } @@ -363,6 +363,9 @@ func (so *stateObject) SetNonce(nonce uint64) { } func (so *stateObject) setNonce(nonce uint64) { + if so.address == libcommon.HexToAddress("0x71562b71999873DB5b286dF957af199Ec94617F7") { + println("set it higher", nonce, dbg.Stack()) + } so.data.Nonce = nonce } diff --git a/core/state_processor.go b/core/state_processor.go index 86278d21f15..2e99e2d7567 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -60,7 +60,8 @@ func applyTransaction(config *chain.Config, engine consensus.EngineReader, gp *G // Update the evm with the new transaction context. evm.Reset(txContext, ibs) - + println("IN ApplyTransaction") + ibs.PrintNonceOfTestAddr() result, err := ApplyMessage(evm, msg, gp, true /* refunds */, false /* gasBailout */) if err != nil { return nil, nil, err diff --git a/core/state_transition.go b/core/state_transition.go index 511c3b91a7b..37200f25309 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -315,8 +315,11 @@ func (st *StateTransition) preCheck(gasBailout bool) error { // nil evm execution result. func (st *StateTransition) TransitionDb(refunds bool, gasBailout bool) (*evmtypes.ExecutionResult, error) { coinbase := st.evm.Context.Coinbase - + println("IN TRANSITION DB BEFORE GETBALANCE") + st.state.PrintNonceOfTestAddr() senderInitBalance := st.state.GetBalance(st.msg.From()).Clone() + println("IN TRANSITION DB AFTER GETBALANCE") + st.state.PrintNonceOfTestAddr() coinbaseInitBalance := st.state.GetBalance(coinbase).Clone() // First check this message satisfies all consensus rules before @@ -445,6 +448,7 @@ func (st *StateTransition) TransitionDb(refunds bool, gasBailout bool) (*evmtype ret, _, st.gasRemaining, vmerr = st.evm.Create(sender, st.data, st.gasRemaining, st.value, bailout) } else { // Increment the nonce for the next transaction + println("incrementing nonce:", msg.From().Hex(), st.state.GetNonce(sender.Address())) st.state.SetNonce(msg.From(), st.state.GetNonce(sender.Address())+1) ret, st.gasRemaining, vmerr = st.evm.Call(sender, st.to(), st.data, st.gasRemaining, st.value, bailout) } diff --git a/core/vm/evmtypes/evmtypes.go b/core/vm/evmtypes/evmtypes.go index 15e8e049ea5..7516bd29fa6 100644 --- a/core/vm/evmtypes/evmtypes.go +++ b/core/vm/evmtypes/evmtypes.go @@ -171,4 +171,5 @@ type IntraBlockState interface { Snapshot() int AddLog(*types.Log) + PrintNonceOfTestAddr() } diff --git a/eth/stagedsync/exec3.go b/eth/stagedsync/exec3.go index 879d31dfa4b..a1ac28213c0 100644 --- a/eth/stagedsync/exec3.go +++ b/eth/stagedsync/exec3.go @@ -169,6 +169,7 @@ func ExecV3(ctx context.Context, maxBlockNum uint64, logger log.Logger, initialCycle bool, + isMining bool, ) error { // TODO: e35 doesn't support parallel-exec yet parallel = false //nolint @@ -356,7 +357,7 @@ func ExecV3(ctx context.Context, rwsConsumed := make(chan struct{}, 1) defer close(rwsConsumed) - execWorkers, applyWorker, rws, stopWorkers, waitWorkers := exec3.NewWorkersPool(lock.RLocker(), accumulator, logger, ctx, parallel, chainDb, rs, in, blockReader, chainConfig, genesis, engine, workerCount+1, cfg.dirs) + execWorkers, applyWorker, rws, stopWorkers, waitWorkers := exec3.NewWorkersPool(lock.RLocker(), accumulator, logger, ctx, parallel, chainDb, rs, in, blockReader, chainConfig, genesis, engine, workerCount+1, cfg.dirs, isMining) defer stopWorkers() applyWorker.DiscardReadList() @@ -386,7 +387,7 @@ func ExecV3(ctx context.Context, return err } - processedTxNum, conflicts, triggers, processedBlockNum, stoppedAtBlockEnd, err := processResultQueue(ctx, in, rws, outputTxNum.Load(), rs, agg, tx, rwsConsumed, applyWorker, true, false) + processedTxNum, conflicts, triggers, processedBlockNum, stoppedAtBlockEnd, err := processResultQueue(ctx, in, rws, outputTxNum.Load(), rs, agg, tx, rwsConsumed, applyWorker, true, false, isMining) if err != nil { return err } @@ -488,7 +489,7 @@ func ExecV3(ctx context.Context, rws.DrainNonBlocking() applyWorker.ResetTx(tx) - processedTxNum, conflicts, triggers, processedBlockNum, stoppedAtBlockEnd, err := processResultQueue(ctx, in, rws, outputTxNum.Load(), rs, agg, tx, nil, applyWorker, false, true) + processedTxNum, conflicts, triggers, processedBlockNum, stoppedAtBlockEnd, err := processResultQueue(ctx, in, rws, outputTxNum.Load(), rs, agg, tx, nil, applyWorker, false, true, isMining) if err != nil { return err } @@ -793,7 +794,7 @@ Loop: if txTask.Error != nil { break Loop } - applyWorker.RunTxTaskNoLock(txTask) + applyWorker.RunTxTaskNoLock(txTask, isMining) if err := func() error { if errors.Is(txTask.Error, context.Canceled) { return err @@ -830,13 +831,17 @@ Loop: return err } if errors.Is(err, consensus.ErrInvalidBlock) { - fmt.Printf("[dbg] in unwindTo %T/n", applyTx) - if err := u.UnwindTo(blockNum-1, BadBlock(header.Hash(), err), applyTx); err != nil { - return err + fmt.Printf("[dbg] in unwindTo %T\n", applyTx) + if u != nil { + if err := u.UnwindTo(blockNum-1, BadBlock(header.Hash(), err), applyTx); err != nil { + return err + } } } else { - if err := u.UnwindTo(blockNum-1, ExecUnwind, applyTx); err != nil { - return err + if u != nil { + if err := u.UnwindTo(blockNum-1, ExecUnwind, applyTx); err != nil { + return err + } } } break Loop @@ -1164,7 +1169,7 @@ func blockWithSenders(ctx context.Context, db kv.RoDB, tx kv.Tx, blockReader ser return b, err } -func processResultQueue(ctx context.Context, in *state.QueueWithRetry, rws *state.ResultsQueue, outputTxNumIn uint64, rs *state.StateV3, agg *state2.Aggregator, applyTx kv.Tx, backPressure chan struct{}, applyWorker *exec3.Worker, canRetry, forceStopAtBlockEnd bool) (outputTxNum uint64, conflicts, triggers int, processedBlockNum uint64, stopedAtBlockEnd bool, err error) { +func processResultQueue(ctx context.Context, in *state.QueueWithRetry, rws *state.ResultsQueue, outputTxNumIn uint64, rs *state.StateV3, agg *state2.Aggregator, applyTx kv.Tx, backPressure chan struct{}, applyWorker *exec3.Worker, canRetry, forceStopAtBlockEnd bool, isMining bool) (outputTxNum uint64, conflicts, triggers int, processedBlockNum uint64, stopedAtBlockEnd bool, err error) { rwsIt := rws.Iter() defer rwsIt.Close() @@ -1182,7 +1187,7 @@ func processResultQueue(ctx context.Context, in *state.QueueWithRetry, rws *stat } // resolve first conflict right here: it's faster and conflict-free - applyWorker.RunTxTask(txTask) + applyWorker.RunTxTask(txTask, isMining) if txTask.Error != nil { return outputTxNum, conflicts, triggers, processedBlockNum, false, fmt.Errorf("%w: %v", consensus.ErrInvalidBlock, txTask.Error) } diff --git a/eth/stagedsync/stage_execute.go b/eth/stagedsync/stage_execute.go index 0138db71698..2996376b016 100644 --- a/eth/stagedsync/stage_execute.go +++ b/eth/stagedsync/stage_execute.go @@ -130,7 +130,7 @@ func StageExecuteBlocksCfg( // ================ Erigon3 ================ -func ExecBlockV3(s *StageState, u Unwinder, txc wrap.TxContainer, toBlock uint64, ctx context.Context, cfg ExecuteBlockCfg, initialCycle bool, logger log.Logger) (err error) { +func ExecBlockV3(s *StageState, u Unwinder, txc wrap.TxContainer, toBlock uint64, ctx context.Context, cfg ExecuteBlockCfg, initialCycle bool, logger log.Logger, isMining bool) (err error) { workersCount := cfg.syncCfg.ExecWorkerCount if !initialCycle { workersCount = 1 @@ -150,7 +150,7 @@ func ExecBlockV3(s *StageState, u Unwinder, txc wrap.TxContainer, toBlock uint64 } parallel := txc.Tx == nil - if err := ExecV3(ctx, s, u, workersCount, cfg, txc, parallel, to, logger, initialCycle); err != nil { + if err := ExecV3(ctx, s, u, workersCount, cfg, txc, parallel, to, logger, initialCycle, isMining); err != nil { return err } return nil @@ -237,7 +237,7 @@ func SpawnExecuteBlocksStage(s *StageState, u Unwinder, txc wrap.TxContainer, to if dbg.StagesOnlyBlocks { return nil } - if err = ExecBlockV3(s, u, txc, toBlock, ctx, cfg, s.CurrentSyncCycle.IsInitialCycle, logger); err != nil { + if err = ExecBlockV3(s, u, txc, toBlock, ctx, cfg, s.CurrentSyncCycle.IsInitialCycle, logger, false); err != nil { return err } return nil diff --git a/eth/stagedsync/stage_mining_exec.go b/eth/stagedsync/stage_mining_exec.go index adbe1cb5b1d..ba581943157 100644 --- a/eth/stagedsync/stage_mining_exec.go +++ b/eth/stagedsync/stage_mining_exec.go @@ -19,6 +19,8 @@ package stagedsync import ( "errors" "fmt" + "github.com/erigontech/erigon-lib/kv/membatchwithdb" + state2 "github.com/erigontech/erigon-lib/state" "io" "math/big" "sync/atomic" @@ -136,7 +138,16 @@ func SpawnMiningExecStage(s *StageState, txc wrap.TxContainer, cfg MiningExecCfg var simStateReader state.StateReader var simStateWriter state.StateWriter simStateReader = state.NewReaderV4(txc.Doms) - simStateWriter = state.NewWriterV4(txc.Doms) + //simStateWriter = state.NewWriterV4(txc.Doms) + mb := membatchwithdb.NewMemoryBatch(txc.Tx, "", logger) //TODO: change tmp dir + defer mb.Rollback() + + sd, err := state2.NewSharedDomains(mb, logger) + if err != nil { + return err + } + defer sd.Close() + simStateWriter = state.NewWriterV4(sd) executionAt, err := s.ExecutionAt(txc.Tx) if err != nil { @@ -228,7 +239,7 @@ func SpawnMiningExecStage(s *StageState, txc wrap.TxContainer, cfg MiningExecCfg // This flag will skip checking the state root execCfg.blockProduction = true execS := &StageState{state: s.state, ID: stages.Execution, BlockNumber: blockHeight - 1} - if err = ExecBlockV3(execS, u, txc, blockHeight, context.Background(), execCfg, false, logger); err != nil { + if err = ExecBlockV3(execS, u, txc, blockHeight, context.Background(), execCfg, false, logger, true); err != nil { logger.Error("cannot execute block execution", "err", err) return err } @@ -413,6 +424,9 @@ func filterBadTransactions(transactions []types.Transaction, config chain.Config // Updates account in the simulation newAccount.Nonce++ newAccount.Balance.Sub(&account.Balance, want) + if sender == libcommon.HexToAddress("0x71562b71999873DB5b286dF957af199Ec94617F7") { + println("FILTERED NONCE IS", newAccount.Nonce) + } if err := simStateWriter.UpdateAccountData(sender, account, newAccount); err != nil { return nil, err } @@ -439,6 +453,8 @@ func addTransactionsToMiningBlock(logPrefix string, current *MiningBlock, chainC noop := state.NewNoopWriter() var miningCommitTx = func(txn types.Transaction, coinbase libcommon.Address, vmConfig *vm.Config, chainConfig chain.Config, ibs *state.IntraBlockState, current *MiningBlock) ([]*types.Log, error) { + println("IN MINING COMMIT") + ibs.PrintNonceOfTestAddr() ibs.SetTxContext(txn.Hash(), libcommon.Hash{}, tcount) gasSnap := gasPool.Gas() blobGasSnap := gasPool.BlobGas() @@ -523,7 +539,7 @@ LOOP: txs.Pop() } else if errors.Is(err, core.ErrNonceTooLow) { // New head notification data race between the transaction pool and miner, shift - logger.Debug(fmt.Sprintf("[%s] Skipping transaction with low nonce", logPrefix), "hash", txn.Hash(), "sender", from, "nonce", txn.GetNonce()) + logger.Debug(fmt.Sprintf("[%s] Skipping transaction with low nonce", logPrefix), "hash", txn.Hash(), "sender", from, "nonce", txn.GetNonce(), "err", err) txs.Shift() } else if errors.Is(err, core.ErrNonceTooHigh) { // Reorg notification data race between the transaction pool and miner, skip account = diff --git a/eth/stagedsync/stagebuilder.go b/eth/stagedsync/stagebuilder.go index 078ffe77b6b..c8c71db1098 100644 --- a/eth/stagedsync/stagebuilder.go +++ b/eth/stagedsync/stagebuilder.go @@ -76,7 +76,7 @@ func MiningStages( ID: stages.MiningExecution, Description: "Mining: execute new block from txn pool", Forward: func(badBlockUnwind bool, s *StageState, u Unwinder, txc wrap.TxContainer, logger log.Logger) error { - return SpawnMiningExecStage(s, txc, execCfg, sendersCfg, executeBlockCfg, ctx, logger, u) + return SpawnMiningExecStage(s, txc, execCfg, sendersCfg, executeBlockCfg, ctx, logger, nil) }, Unwind: func(u *UnwindState, s *StageState, txc wrap.TxContainer, logger log.Logger) error { return nil From c1a24e012e86f4f7a92ffe2db7e2b94a2ed1670f Mon Sep 17 00:00:00 2001 From: JkLondon Date: Wed, 7 Aug 2024 13:22:58 +0400 Subject: [PATCH 26/53] a lot of logging removed + fix of nonces --- cmd/state/exec3/state.go | 9 ++------- core/state/intra_block_state.go | 15 --------------- core/state/state_object.go | 4 ---- core/state_processor.go | 2 -- core/state_transition.go | 5 ----- core/vm/evmtypes/evmtypes.go | 1 - eth/stagedsync/stage_mining_exec.go | 9 ++------- 7 files changed, 4 insertions(+), 41 deletions(-) diff --git a/cmd/state/exec3/state.go b/cmd/state/exec3/state.go index efd9981a378..5b07a693c97 100644 --- a/cmd/state/exec3/state.go +++ b/cmd/state/exec3/state.go @@ -18,7 +18,6 @@ package exec3 import ( "context" - "fmt" "sync" "golang.org/x/sync/errgroup" @@ -167,13 +166,9 @@ func (rw *Worker) RunTxTaskNoLock(txTask *state.TxTask, isMining bool) { // in case if we cancelled execution and commitment happened in the middle of the block, we have to process block // from the beginning until committed txNum and only then disable history mode. // Needed to correctly evaluate spent gas and other things. - println("history mode not enabled") rw.SetReader(state.NewHistoryReaderV3()) } else if !txTask.HistoryExecution && rw.historyMode { - println("history mode enabled") rw.SetReader(state.NewStateReaderV3(rw.rs.Domains())) - } else { - rw.logger.Error("RunTxTaskNoLock", "HistoryExecution", txTask.HistoryExecution, "HistoryMode", rw.historyMode, "reader", rw.stateReader) } if rw.background && rw.chainTx == nil { var err error @@ -184,7 +179,7 @@ func (rw *Worker) RunTxTaskNoLock(txTask *state.TxTask, isMining bool) { rw.stateWriter.SetTx(rw.chainTx) rw.chain = consensuschain.NewReader(rw.chainConfig, rw.chainTx, rw.blockReader, rw.logger) } - fmt.Printf("[dbg] in RunTxTaskNoLock %T\n", rw.chainTx) + txTask.Error = nil rw.stateReader.SetTxNum(txTask.TxNum) @@ -234,7 +229,7 @@ func (rw *Worker) RunTxTaskNoLock(txTask *state.TxTask, isMining bool) { } if isMining { - _, _, _, err = rw.engine.FinalizeAndAssemble(rw.chainConfig, types.CopyHeader(header), ibs, txTask.Txs, txTask.Uncles, txTask.BlockReceipts, txTask.Withdrawals, txTask.Requests, rw.chain, syscall, nil, rw.logger) + _, txTask.Txs, txTask.BlockReceipts, err = rw.engine.FinalizeAndAssemble(rw.chainConfig, types.CopyHeader(header), ibs, txTask.Txs, txTask.Uncles, txTask.BlockReceipts, txTask.Withdrawals, txTask.Requests, rw.chain, syscall, nil, rw.logger) } else { _, _, _, err = rw.engine.Finalize(rw.chainConfig, types.CopyHeader(header), ibs, txTask.Txs, txTask.Uncles, txTask.BlockReceipts, txTask.Withdrawals, txTask.Requests, rw.chain, syscall, rw.logger) } diff --git a/core/state/intra_block_state.go b/core/state/intra_block_state.go index a20a8e58588..970fc10c33d 100644 --- a/core/state/intra_block_state.go +++ b/core/state/intra_block_state.go @@ -25,7 +25,6 @@ import ( "fmt" "github.com/erigontech/erigon-lib/chain" libcommon "github.com/erigontech/erigon-lib/common" - "github.com/erigontech/erigon-lib/common/dbg" types2 "github.com/erigontech/erigon-lib/types" "github.com/erigontech/erigon/common/u256" "github.com/erigontech/erigon/core/tracing" @@ -114,14 +113,6 @@ func New(stateReader StateReader) *IntraBlockState { } } -func (sdb *IntraBlockState) PrintNonceOfTestAddr() { - if obj, ok := sdb.stateObjects[libcommon.HexToAddress("0x71562b71999873DB5b286dF957af199Ec94617F7")]; !ok { - println("NO NONCE FOR TEST ADDRESS") - } else { - println("NONCE IS:", obj.Nonce()) - } -} - func (sdb *IntraBlockState) SetTrace(trace bool) { sdb.trace = trace } @@ -236,9 +227,6 @@ func (sdb *IntraBlockState) GetBalance(addr libcommon.Address) *uint256.Int { func (sdb *IntraBlockState) GetNonce(addr libcommon.Address) uint64 { stateObject := sdb.getStateObject(addr) if stateObject != nil && !stateObject.deleted { - if addr == libcommon.HexToAddress("0x71562b71999873DB5b286dF957af199Ec94617F7") && stateObject.Nonce() < 60 { - println("get nonce", stateObject.Nonce(), dbg.Stack()) - } return stateObject.Nonce() } @@ -518,13 +506,10 @@ func (sdb *IntraBlockState) getStateObject(addr libcommon.Address) (stateObject } return nil } - println("ACCOUNT NONCE IS", account.Nonce) // Insert into the live set. obj := newObject(sdb, addr, account, account) sdb.setStateObject(addr, obj) - println("IN THE END OF GET STATE OBJECT") - sdb.PrintNonceOfTestAddr() return obj } diff --git a/core/state/state_object.go b/core/state/state_object.go index 7bba7741ade..f2e57088ebc 100644 --- a/core/state/state_object.go +++ b/core/state/state_object.go @@ -22,7 +22,6 @@ package state import ( "bytes" "fmt" - "github.com/erigontech/erigon-lib/common/dbg" "io" "maps" "math/big" @@ -363,9 +362,6 @@ func (so *stateObject) SetNonce(nonce uint64) { } func (so *stateObject) setNonce(nonce uint64) { - if so.address == libcommon.HexToAddress("0x71562b71999873DB5b286dF957af199Ec94617F7") { - println("set it higher", nonce, dbg.Stack()) - } so.data.Nonce = nonce } diff --git a/core/state_processor.go b/core/state_processor.go index 2e99e2d7567..b13b632f276 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -60,8 +60,6 @@ func applyTransaction(config *chain.Config, engine consensus.EngineReader, gp *G // Update the evm with the new transaction context. evm.Reset(txContext, ibs) - println("IN ApplyTransaction") - ibs.PrintNonceOfTestAddr() result, err := ApplyMessage(evm, msg, gp, true /* refunds */, false /* gasBailout */) if err != nil { return nil, nil, err diff --git a/core/state_transition.go b/core/state_transition.go index 37200f25309..f0aae712387 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -315,11 +315,7 @@ func (st *StateTransition) preCheck(gasBailout bool) error { // nil evm execution result. func (st *StateTransition) TransitionDb(refunds bool, gasBailout bool) (*evmtypes.ExecutionResult, error) { coinbase := st.evm.Context.Coinbase - println("IN TRANSITION DB BEFORE GETBALANCE") - st.state.PrintNonceOfTestAddr() senderInitBalance := st.state.GetBalance(st.msg.From()).Clone() - println("IN TRANSITION DB AFTER GETBALANCE") - st.state.PrintNonceOfTestAddr() coinbaseInitBalance := st.state.GetBalance(coinbase).Clone() // First check this message satisfies all consensus rules before @@ -448,7 +444,6 @@ func (st *StateTransition) TransitionDb(refunds bool, gasBailout bool) (*evmtype ret, _, st.gasRemaining, vmerr = st.evm.Create(sender, st.data, st.gasRemaining, st.value, bailout) } else { // Increment the nonce for the next transaction - println("incrementing nonce:", msg.From().Hex(), st.state.GetNonce(sender.Address())) st.state.SetNonce(msg.From(), st.state.GetNonce(sender.Address())+1) ret, st.gasRemaining, vmerr = st.evm.Call(sender, st.to(), st.data, st.gasRemaining, st.value, bailout) } diff --git a/core/vm/evmtypes/evmtypes.go b/core/vm/evmtypes/evmtypes.go index 7516bd29fa6..15e8e049ea5 100644 --- a/core/vm/evmtypes/evmtypes.go +++ b/core/vm/evmtypes/evmtypes.go @@ -171,5 +171,4 @@ type IntraBlockState interface { Snapshot() int AddLog(*types.Log) - PrintNonceOfTestAddr() } diff --git a/eth/stagedsync/stage_mining_exec.go b/eth/stagedsync/stage_mining_exec.go index ba581943157..ea9958e8bca 100644 --- a/eth/stagedsync/stage_mining_exec.go +++ b/eth/stagedsync/stage_mining_exec.go @@ -137,9 +137,8 @@ func SpawnMiningExecStage(s *StageState, txc wrap.TxContainer, cfg MiningExecCfg yielded := mapset.NewSet[[32]byte]() var simStateReader state.StateReader var simStateWriter state.StateWriter - simStateReader = state.NewReaderV4(txc.Doms) //simStateWriter = state.NewWriterV4(txc.Doms) - mb := membatchwithdb.NewMemoryBatch(txc.Tx, "", logger) //TODO: change tmp dir + mb := membatchwithdb.NewMemoryBatch(txc.Tx, cfg.tmpdir, logger) defer mb.Rollback() sd, err := state2.NewSharedDomains(mb, logger) @@ -148,6 +147,7 @@ func SpawnMiningExecStage(s *StageState, txc wrap.TxContainer, cfg MiningExecCfg } defer sd.Close() simStateWriter = state.NewWriterV4(sd) + simStateReader = state.NewReaderV4(sd) executionAt, err := s.ExecutionAt(txc.Tx) if err != nil { @@ -424,9 +424,6 @@ func filterBadTransactions(transactions []types.Transaction, config chain.Config // Updates account in the simulation newAccount.Nonce++ newAccount.Balance.Sub(&account.Balance, want) - if sender == libcommon.HexToAddress("0x71562b71999873DB5b286dF957af199Ec94617F7") { - println("FILTERED NONCE IS", newAccount.Nonce) - } if err := simStateWriter.UpdateAccountData(sender, account, newAccount); err != nil { return nil, err } @@ -453,8 +450,6 @@ func addTransactionsToMiningBlock(logPrefix string, current *MiningBlock, chainC noop := state.NewNoopWriter() var miningCommitTx = func(txn types.Transaction, coinbase libcommon.Address, vmConfig *vm.Config, chainConfig chain.Config, ibs *state.IntraBlockState, current *MiningBlock) ([]*types.Log, error) { - println("IN MINING COMMIT") - ibs.PrintNonceOfTestAddr() ibs.SetTxContext(txn.Hash(), libcommon.Hash{}, tcount) gasSnap := gasPool.Gas() blobGasSnap := gasPool.BlobGas() From f85ec9970c6c09e5a482880e3e1c4a712b8f4254 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Wed, 7 Aug 2024 13:29:35 +0400 Subject: [PATCH 27/53] added mining flag --- eth/stagedsync/exec3.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/eth/stagedsync/exec3.go b/eth/stagedsync/exec3.go index a1ac28213c0..29723f092e3 100644 --- a/eth/stagedsync/exec3.go +++ b/eth/stagedsync/exec3.go @@ -908,7 +908,7 @@ Loop: t1, t2, t3 time.Duration ) - if ok, err := flushAndCheckCommitmentV3(ctx, b.HeaderNoCopy(), applyTx, doms, cfg, execStage, stageProgress, parallel, logger, u, inMemExec); err != nil { + if ok, err := flushAndCheckCommitmentV3(ctx, b.HeaderNoCopy(), applyTx, doms, cfg, execStage, stageProgress, parallel, logger, u, inMemExec, isMining); err != nil { return err } else if !ok { break Loop @@ -994,7 +994,7 @@ Loop: if u != nil && !u.HasUnwindPoint() { if b != nil { - _, err := flushAndCheckCommitmentV3(ctx, b.HeaderNoCopy(), applyTx, doms, cfg, execStage, stageProgress, parallel, logger, u, inMemExec) + _, err := flushAndCheckCommitmentV3(ctx, b.HeaderNoCopy(), applyTx, doms, cfg, execStage, stageProgress, parallel, logger, u, inMemExec, isMining) if err != nil { return err } @@ -1068,7 +1068,7 @@ func dumpPlainStateDebug(tx kv.RwTx, doms *state2.SharedDomains) { } // flushAndCheckCommitmentV3 - does write state to db and then check commitment -func flushAndCheckCommitmentV3(ctx context.Context, header *types.Header, applyTx kv.RwTx, doms *state2.SharedDomains, cfg ExecuteBlockCfg, e *StageState, maxBlockNum uint64, parallel bool, logger log.Logger, u Unwinder, inMemExec bool) (bool, error) { +func flushAndCheckCommitmentV3(ctx context.Context, header *types.Header, applyTx kv.RwTx, doms *state2.SharedDomains, cfg ExecuteBlockCfg, e *StageState, maxBlockNum uint64, parallel bool, logger log.Logger, u Unwinder, inMemExec bool, isMining bool) (bool, error) { // E2 state root check was in another stage - means we did flush state even if state root will not match // And Unwind expecting it @@ -1099,7 +1099,7 @@ func flushAndCheckCommitmentV3(ctx context.Context, header *types.Header, applyT if cfg.blockProduction { return true, nil } - if bytes.Equal(rh, header.Root.Bytes()) { + if !isMining || bytes.Equal(rh, header.Root.Bytes()) { if !inMemExec { if err := doms.Flush(ctx, applyTx); err != nil { return false, err From 8f6c2323f121306bd78e025531eb4b385ce2d01d Mon Sep 17 00:00:00 2001 From: JkLondon Date: Wed, 7 Aug 2024 13:46:13 +0400 Subject: [PATCH 28/53] fix of tests --- eth/stagedsync/exec3.go | 2 +- tests/testdata | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/eth/stagedsync/exec3.go b/eth/stagedsync/exec3.go index 29723f092e3..f1346e9e8cd 100644 --- a/eth/stagedsync/exec3.go +++ b/eth/stagedsync/exec3.go @@ -1099,7 +1099,7 @@ func flushAndCheckCommitmentV3(ctx context.Context, header *types.Header, applyT if cfg.blockProduction { return true, nil } - if !isMining || bytes.Equal(rh, header.Root.Bytes()) { + if isMining || bytes.Equal(rh, header.Root.Bytes()) { if !inMemExec { if err := doms.Flush(ctx, applyTx); err != nil { return false, err diff --git a/tests/testdata b/tests/testdata index 853b1e03b10..e46e1db503e 160000 --- a/tests/testdata +++ b/tests/testdata @@ -1 +1 @@ -Subproject commit 853b1e03b1078d370614002851ba1ee9803d9fcf +Subproject commit e46e1db503ee2711ad02e1f5b3ea45d43e9cd8cb From c54525f6ef274e9b5f352c1571e1511d189b7260 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Wed, 7 Aug 2024 14:04:11 +0400 Subject: [PATCH 29/53] fix --- eth/stagedsync/exec3.go | 2 +- eth/stagedsync/stage_mining_finish.go | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/eth/stagedsync/exec3.go b/eth/stagedsync/exec3.go index f1346e9e8cd..001c47fe031 100644 --- a/eth/stagedsync/exec3.go +++ b/eth/stagedsync/exec3.go @@ -807,7 +807,7 @@ Loop: blobGasUsed += txTask.Tx.GetBlobGas() } if txTask.Final { - checkReceipts := !cfg.vmConfig.StatelessExec && chainConfig.IsByzantium(txTask.BlockNum) && !cfg.vmConfig.NoReceipts + checkReceipts := !cfg.vmConfig.StatelessExec && chainConfig.IsByzantium(txTask.BlockNum) && !cfg.vmConfig.NoReceipts && !isMining if txTask.BlockNum > 0 && !skipPostEvaluation { //Disable check for genesis. Maybe need somehow improve it in future - to satisfy TestExecutionSpec if err := core.BlockPostValidation(usedGas, blobGasUsed, checkReceipts, receipts, txTask.Header); err != nil { return fmt.Errorf("%w, txnIdx=%d, %v", consensus.ErrInvalidBlock, txTask.TxIndex, err) //same as in stage_exec.go diff --git a/eth/stagedsync/stage_mining_finish.go b/eth/stagedsync/stage_mining_finish.go index 576f755b1e7..b23997677cc 100644 --- a/eth/stagedsync/stage_mining_finish.go +++ b/eth/stagedsync/stage_mining_finish.go @@ -103,6 +103,7 @@ func SpawnMiningFinishStage(s *StageState, tx kv.RwTx, cfg MiningFinishCfg, quit "gasUsed", block.GasUsed(), "gasLimit", block.GasLimit(), "difficulty", block.Difficulty(), + "header", block.Header(), ) } // interrupt aborts the in-flight sealing task. From 7a145d32c61a88aa1caba67dba2d476b68284172 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Thu, 8 Aug 2024 13:32:04 +0400 Subject: [PATCH 30/53] fix --- core/blockchain.go | 8 ++++++-- erigon-lib/state/domain_shared.go | 19 ++++++++++++++++++- eth/stagedsync/exec3.go | 25 ++++++++++++++++--------- 3 files changed, 40 insertions(+), 12 deletions(-) diff --git a/core/blockchain.go b/core/blockchain.go index ca451756beb..cb1ad1b8d18 100644 --- a/core/blockchain.go +++ b/core/blockchain.go @@ -334,7 +334,7 @@ func FinalizeBlockExecution( newBlock, newTxs, newReceipt, err = engine.FinalizeAndAssemble(cc, header, ibs, txs, uncles, receipts, withdrawals, requests, chainReader, syscall, nil, logger) } else { var rss types.Requests - _, _, rss, err = engine.Finalize(cc, header, ibs, txs, uncles, receipts, withdrawals, requests, chainReader, syscall, logger) + newTxs, newReceipt, rss, err = engine.Finalize(cc, header, ibs, txs, uncles, receipts, withdrawals, requests, chainReader, syscall, logger) if !reflect.DeepEqual(rss, requests) { return nil, nil, nil, fmt.Errorf("invalid requests for block %d", header.Number.Uint64()) @@ -367,7 +367,7 @@ func InitializeBlockExecution(engine consensus.Engine, chain consensus.ChainHead return nil } -func BlockPostValidation(gasUsed, blobGasUsed uint64, checkReceipts bool, receipts types.Receipts, h *types.Header) error { +func BlockPostValidation(gasUsed, blobGasUsed uint64, checkReceipts bool, receipts types.Receipts, h *types.Header, isMining bool) error { if gasUsed != h.GasUsed { return fmt.Errorf("gas used by execution: %d, in header: %d, headerNum=%d, %x", gasUsed, h.GasUsed, h.Number.Uint64(), h.Hash()) @@ -383,6 +383,10 @@ func BlockPostValidation(gasUsed, blobGasUsed uint64, checkReceipts bool, receip } receiptHash := types.DeriveSha(receipts) if receiptHash != h.ReceiptHash { + if isMining { + h.ReceiptHash = receiptHash + return nil + } return fmt.Errorf("receiptHash mismatch: %x != %x, headerNum=%d, %x", receiptHash, h.ReceiptHash, h.Number.Uint64(), h.Hash()) } diff --git a/erigon-lib/state/domain_shared.go b/erigon-lib/state/domain_shared.go index 68fd2601e31..5b8ddac086c 100644 --- a/erigon-lib/state/domain_shared.go +++ b/erigon-lib/state/domain_shared.go @@ -1185,6 +1185,7 @@ func (sdc *SharedDomainsCommitmentContext) ComputeCommitment(ctx context.Context if sdc.sharedDomains.trace { defer sdc.sharedDomains.logger.Trace("ComputeCommitment", "block", blockNum, "keys", updateCount, "mode", sdc.mode) } + if updateCount == 0 { rootHash, err = sdc.patriciaTrie.RootHash() return rootHash, err @@ -1193,9 +1194,25 @@ func (sdc *SharedDomainsCommitmentContext) ComputeCommitment(ctx context.Context // data accessing functions should be set when domain is opened/shared context updated sdc.patriciaTrie.SetTrace(sdc.sharedDomains.trace) sdc.Reset() - + println("patricia mode:", sdc.mode.String(), sdc.sharedDomains.trace) switch sdc.mode { case commitment.ModeDirect: + if blockNum == 3 { + println("in patricia tree", logPrefix) + println("size", sdc.updates.Size()) + list, upd := sdc.updates.List(false) + println("list") + for i := range list { + for j := range list[i] { + print(list[i][j], "/") + } + println() + } + println("upd") + for _, u := range upd { + println(u.String()) + } + } rootHash, err = sdc.patriciaTrie.ProcessTree(ctx, sdc.updates, logPrefix) if err != nil { return nil, err diff --git a/eth/stagedsync/exec3.go b/eth/stagedsync/exec3.go index 001c47fe031..cf208caf714 100644 --- a/eth/stagedsync/exec3.go +++ b/eth/stagedsync/exec3.go @@ -807,9 +807,9 @@ Loop: blobGasUsed += txTask.Tx.GetBlobGas() } if txTask.Final { - checkReceipts := !cfg.vmConfig.StatelessExec && chainConfig.IsByzantium(txTask.BlockNum) && !cfg.vmConfig.NoReceipts && !isMining - if txTask.BlockNum > 0 && !skipPostEvaluation { //Disable check for genesis. Maybe need somehow improve it in future - to satisfy TestExecutionSpec - if err := core.BlockPostValidation(usedGas, blobGasUsed, checkReceipts, receipts, txTask.Header); err != nil { + checkReceipts := !cfg.vmConfig.StatelessExec && chainConfig.IsByzantium(txTask.BlockNum) && !cfg.vmConfig.NoReceipts // && !isMining + if txTask.BlockNum > 0 && !skipPostEvaluation { //Disable check for genesis. Maybe need somehow improve it in future - to satisfy TestExecutionSpec + if err := core.BlockPostValidation(usedGas, blobGasUsed, checkReceipts, receipts, txTask.Header, isMining); err != nil { return fmt.Errorf("%w, txnIdx=%d, %v", consensus.ErrInvalidBlock, txTask.TxIndex, err) //same as in stage_exec.go } } @@ -992,7 +992,7 @@ Loop: waitWorkers() } - if u != nil && !u.HasUnwindPoint() { + if isMining || u != nil && !u.HasUnwindPoint() { if b != nil { _, err := flushAndCheckCommitmentV3(ctx, b.HeaderNoCopy(), applyTx, doms, cfg, execStage, stageProgress, parallel, logger, u, inMemExec, isMining) if err != nil { @@ -1091,15 +1091,20 @@ func flushAndCheckCommitmentV3(ctx context.Context, header *types.Header, applyT if doms.BlockNum() != header.Number.Uint64() { panic(fmt.Errorf("%d != %d", doms.BlockNum(), header.Number.Uint64())) } - - rh, err := doms.ComputeCommitment(ctx, true, header.Number.Uint64(), u.LogPrefix()) + logPrefix := "mining" + if u != nil { + logPrefix = u.LogPrefix() + } + rh, err := doms.ComputeCommitment(ctx, true, header.Number.Uint64(), logPrefix) if err != nil { return false, fmt.Errorf("StateV3.Apply: %w", err) } if cfg.blockProduction { + println("HEADER ROOT IS2", header.Root.Hex(), common.BytesToHash(rh).Hex()) + header.Root = common.BytesToHash(rh) return true, nil } - if isMining || bytes.Equal(rh, header.Root.Bytes()) { + if bytes.Equal(rh, header.Root.Bytes()) { if !inMemExec { if err := doms.Flush(ctx, applyTx); err != nil { return false, err @@ -1142,8 +1147,10 @@ func flushAndCheckCommitmentV3(ctx context.Context, header *types.Header, applyT return false, fmt.Errorf("%w: requested=%d, minAllowed=%d", ErrTooDeepUnwind, unwindTo, allowedUnwindTo) } logger.Warn("Unwinding due to incorrect root hash", "to", unwindTo) - if err := u.UnwindTo(allowedUnwindTo, BadBlock(header.Hash(), ErrInvalidStateRootHash), applyTx); err != nil { - return false, err + if u != nil { + if err := u.UnwindTo(allowedUnwindTo, BadBlock(header.Hash(), ErrInvalidStateRootHash), applyTx); err != nil { + return false, err + } } return false, nil } From 58194809d4cb832f8ad60ef60405cbbb57df460f Mon Sep 17 00:00:00 2001 From: JkLondon Date: Thu, 8 Aug 2024 14:04:20 +0400 Subject: [PATCH 31/53] removed unused err logs --- erigon-lib/state/domain_shared.go | 30 +++++++++++---------- eth/stagedsync/sync.go | 4 +-- turbo/shards/state_change_accumulator.go | 5 ---- turbo/stages/headerdownload/header_algos.go | 1 - turbo/stages/stageloop.go | 8 ------ 5 files changed, 17 insertions(+), 31 deletions(-) diff --git a/erigon-lib/state/domain_shared.go b/erigon-lib/state/domain_shared.go index 5b8ddac086c..c45f319d06d 100644 --- a/erigon-lib/state/domain_shared.go +++ b/erigon-lib/state/domain_shared.go @@ -1194,26 +1194,28 @@ func (sdc *SharedDomainsCommitmentContext) ComputeCommitment(ctx context.Context // data accessing functions should be set when domain is opened/shared context updated sdc.patriciaTrie.SetTrace(sdc.sharedDomains.trace) sdc.Reset() - println("patricia mode:", sdc.mode.String(), sdc.sharedDomains.trace) + //println("patricia mode:", sdc.mode.String(), sdc.sharedDomains.trace) switch sdc.mode { case commitment.ModeDirect: - if blockNum == 3 { + //sdc.updates.List(false) + if blockNum >= 3 { println("in patricia tree", logPrefix) println("size", sdc.updates.Size()) - list, upd := sdc.updates.List(false) - println("list") - for i := range list { - for j := range list[i] { - print(list[i][j], "/") - } - println() - } - println("upd") - for _, u := range upd { - println(u.String()) - } + //list, upd := sdc.updates.List(false) + //println("list") + //for i := range list { + // for j := range list[i] { + // print(list[i][j], "/") + // } + // println() + //} + //println("upd") + //for _, u := range upd { + // println(u.String()) + //} } rootHash, err = sdc.patriciaTrie.ProcessTree(ctx, sdc.updates, logPrefix) + //println("calculated rootHash:", common.BytesToHash(rootHash).Hex()) if err != nil { return nil, err } diff --git a/eth/stagedsync/sync.go b/eth/stagedsync/sync.go index 7b2b7577c6f..6539801efd6 100644 --- a/eth/stagedsync/sync.go +++ b/eth/stagedsync/sync.go @@ -392,7 +392,6 @@ func (s *Sync) Run(db kv.RwDB, txc wrap.TxContainer, initialCycle, firstCycle bo if badBlockUnwind { // If there was a bad block, the current step needs to complete, to send the corresponding reply to the Consensus Layer // Otherwise, the staged sync will get stuck in the Headers stage with "Waiting for Consensus Layer..." - s.logger.Error("I've breaked here btw") break } @@ -409,7 +408,7 @@ func (s *Sync) Run(db kv.RwDB, txc wrap.TxContainer, initialCycle, firstCycle bo s.NextStage() continue } - s.logger.Error("current stage now is", "stage", stage.ID, "stack", dbg.Stack()) + if err := s.runStage(stage, db, txc, initialCycle, firstCycle, badBlockUnwind); err != nil { return false, err } @@ -444,7 +443,6 @@ func (s *Sync) Run(db kv.RwDB, txc wrap.TxContainer, initialCycle, firstCycle bo s.NextStage() } - s.logger.Error("MINING IS OVER!!!!") if err := s.SetCurrentStage(s.stages[0].ID); err != nil { return false, err diff --git a/turbo/shards/state_change_accumulator.go b/turbo/shards/state_change_accumulator.go index 9d3275d5b89..602dd5c7d69 100644 --- a/turbo/shards/state_change_accumulator.go +++ b/turbo/shards/state_change_accumulator.go @@ -56,11 +56,6 @@ func (a *Accumulator) SendAndReset(ctx context.Context, c StateChangeConsumer, p return } sc := &remote.StateChangeBatch{StateVersionId: a.plainStateID, ChangeBatch: a.changes, PendingBlockBaseFee: pendingBaseFee, BlockGasLimit: blockGasLimit, FinalizedBlock: finalizedBlock, PendingBlobFeePerGas: pendingBlobFee} - println("reseting") - for _, change := range a.changes { - println("txs", len(change.Txs)) - } - println("---------------------------------------------") c.SendStateChanges(ctx, sc) a.Reset(0) // reset here for GC, but there will be another Reset with correct viewID } diff --git a/turbo/stages/headerdownload/header_algos.go b/turbo/stages/headerdownload/header_algos.go index ecd6d14b70b..0d3814b5994 100644 --- a/turbo/stages/headerdownload/header_algos.go +++ b/turbo/stages/headerdownload/header_algos.go @@ -392,7 +392,6 @@ func (hd *HeaderDownload) RequestMoreHeaders(currentTime time.Time) (*HeaderRequ defer hd.lock.Unlock() var penalties []PenaltyItem var req *HeaderRequest - hd.logger.Error("[downloader] RequestMoreHeaders", "currentTime", currentTime) hd.anchorTree.Ascend(func(anchor *Anchor) bool { hd.logger.Error("in request more", "anch hash", anchor.parentHash.Hex()) diff --git a/turbo/stages/stageloop.go b/turbo/stages/stageloop.go index e5cb143917f..8e8b1a43853 100644 --- a/turbo/stages/stageloop.go +++ b/turbo/stages/stageloop.go @@ -222,7 +222,6 @@ func StageLoopIteration(ctx context.Context, db kv.RwDB, txc wrap.TxContainer, s }() // avoid crash because Erigon's core does many things externalTx := txc.Tx != nil - println("externalTx", externalTx) finishProgressBefore, borProgressBefore, headersProgressBefore, err := stagesHeadersAndFinish(db, txc.Tx) if err != nil { return err @@ -271,14 +270,11 @@ func StageLoopIteration(ctx context.Context, db kv.RwDB, txc wrap.TxContainer, s logger.Error("BeforeRun err", "err", err) return err } - logger.Error("BeforeRun hook", "hook", hook.chainConfig.ChainID.String()) } - logger.Error("start sync") _, err = sync.Run(db, txc, initialCycle, firstCycle) if err != nil { return err } - logger.Error("finish sync") logCtx := sync.PrintTimings() //var tableSizes []interface{} var commitTime time.Duration @@ -295,7 +291,6 @@ func StageLoopIteration(ctx context.Context, db kv.RwDB, txc wrap.TxContainer, s } // -- send notifications START - logger.Error("trying to after run", "hook nil?", hook == nil) if hook != nil { if err = hook.AfterRun(txc.Tx, finishProgressBefore); err != nil { return err @@ -397,7 +392,6 @@ func (h *Hook) AfterRun(tx kv.Tx, finishProgressBefore uint64) error { } func (h *Hook) afterRun(tx kv.Tx, finishProgressBefore uint64) error { // Update sentry status for peers to see our sync status - h.logger.Error("after run", "finishProgressBefore", finishProgressBefore) if h.updateHead != nil { h.updateHead(h.ctx) } @@ -409,7 +403,6 @@ func (h *Hook) afterRun(tx kv.Tx, finishProgressBefore uint64) error { func (h *Hook) sendNotifications(notifications *shards.Notifications, tx kv.Tx, finishProgressBefore uint64) error { // update the accumulator with a new plain state version so the cache can be notified that // state has moved on - h.logger.Error("starting to send") if notifications.Accumulator != nil { plainStateVersion, err := rawdb.GetStateVersion(tx) if err != nil { @@ -451,7 +444,6 @@ func (h *Hook) sendNotifications(notifications *shards.Notifications, tx kv.Tx, finalizedBlock = *fb } - h.logger.Error("[hook] Sending state changes", "currentBlock", currentHeader.Number.Uint64(), "finalizedBlock", finalizedBlock) notifications.Accumulator.SendAndReset(h.ctx, notifications.StateChangesConsumer, pendingBaseFee.Uint64(), pendingBlobFee, currentHeader.GasLimit, finalizedBlock) } return nil From 7b86a8a7a910d05d188c761c8298d93c8e09992a Mon Sep 17 00:00:00 2001 From: JkLondon Date: Thu, 8 Aug 2024 14:48:10 +0400 Subject: [PATCH 32/53] fix --- erigon-lib/state/domain_shared.go | 2 +- eth/stagedsync/exec3.go | 2 ++ turbo/stages/stageloop.go | 4 ++-- 3 files changed, 5 insertions(+), 3 deletions(-) diff --git a/erigon-lib/state/domain_shared.go b/erigon-lib/state/domain_shared.go index c45f319d06d..34b8323376c 100644 --- a/erigon-lib/state/domain_shared.go +++ b/erigon-lib/state/domain_shared.go @@ -1215,7 +1215,7 @@ func (sdc *SharedDomainsCommitmentContext) ComputeCommitment(ctx context.Context //} } rootHash, err = sdc.patriciaTrie.ProcessTree(ctx, sdc.updates, logPrefix) - //println("calculated rootHash:", common.BytesToHash(rootHash).Hex()) + println("calculated rootHash:", common.BytesToHash(rootHash).Hex()) if err != nil { return nil, err } diff --git a/eth/stagedsync/exec3.go b/eth/stagedsync/exec3.go index cf208caf714..4c5442f1248 100644 --- a/eth/stagedsync/exec3.go +++ b/eth/stagedsync/exec3.go @@ -185,6 +185,7 @@ func ExecV3(ctx context.Context, if !useExternalTx { if !parallel { var err error + println("new tx") applyTx, err = chainDb.BeginRw(ctx) //nolint if err != nil { return err @@ -213,6 +214,7 @@ func ExecV3(ctx context.Context, doms = txc.Doms } else { var err error + println("new sd") doms, err = state2.NewSharedDomains(applyTx, log.New()) // if we are behind the commitment, we can't execute anything // this can heppen if progress in domain is higher than progress in blocks diff --git a/turbo/stages/stageloop.go b/turbo/stages/stageloop.go index 8e8b1a43853..a5db09fd2b1 100644 --- a/turbo/stages/stageloop.go +++ b/turbo/stages/stageloop.go @@ -87,7 +87,7 @@ func StageLoop( } } - //tx, err := db.BeginRw(ctx) + //tx, err := db.BeginRwNosync(ctx) //if err != nil { // logger.Error("BeginRw err", "err", err) // return @@ -250,7 +250,7 @@ func StageLoopIteration(ctx context.Context, db kv.RwDB, txc wrap.TxContainer, s // send notifications Now and do write to disks Later. // - Send Notifications: about new blocks, new receipts, state changes, etc... // - Prune(limited time)+Commit(sync). Write to disk happening here. - + //logger.Error("in stageLooopIT", "canRunCycleInOneTransaction", canRunCycleInOneTransaction) if canRunCycleInOneTransaction && !externalTx { txc.Tx, err = db.BeginRwNosync(ctx) if err != nil { From 262aef223cb6d341088f3c1f8590aac090f47633 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Sat, 10 Aug 2024 19:55:56 +0400 Subject: [PATCH 33/53] added coinbase from header to evm + fixed test + removed useless logs --- core/evm.go | 3 ++- erigon-lib/state/domain_shared.go | 18 ------------------ erigon-lib/txpool/fetch.go | 1 - eth/backend.go | 14 +------------- eth/stagedsync/exec3.go | 11 ++++------- eth/stagedsync/stage_mining_create_block.go | 2 +- eth/stagedsync/stage_mining_exec.go | 2 -- p2p/sentry/sentry_multi_client/broadcast.go | 1 - polygon/bor/bor.go | 2 +- tests/bor/mining_test.go | 3 +-- turbo/shards/state_change_accumulator.go | 4 ---- turbo/stages/stageloop.go | 1 - 12 files changed, 10 insertions(+), 52 deletions(-) diff --git a/core/evm.go b/core/evm.go index 34dcd500316..23d28f5d6cb 100644 --- a/core/evm.go +++ b/core/evm.go @@ -40,7 +40,8 @@ func NewEVMBlockContext(header *types.Header, blockHashFunc func(n uint64) libco // If we don't have an explicit author (i.e. not mining), extract from the header var beneficiary libcommon.Address if author == nil { - beneficiary, _ = engine.Author(header) // Ignore error, we're past header validation + beneficiary = header.Coinbase + //beneficiary, _ = engine.Author(header) // Ignore error, we're past header validation } else { beneficiary = *author } diff --git a/erigon-lib/state/domain_shared.go b/erigon-lib/state/domain_shared.go index 34b8323376c..aa7f0ca5686 100644 --- a/erigon-lib/state/domain_shared.go +++ b/erigon-lib/state/domain_shared.go @@ -1197,25 +1197,7 @@ func (sdc *SharedDomainsCommitmentContext) ComputeCommitment(ctx context.Context //println("patricia mode:", sdc.mode.String(), sdc.sharedDomains.trace) switch sdc.mode { case commitment.ModeDirect: - //sdc.updates.List(false) - if blockNum >= 3 { - println("in patricia tree", logPrefix) - println("size", sdc.updates.Size()) - //list, upd := sdc.updates.List(false) - //println("list") - //for i := range list { - // for j := range list[i] { - // print(list[i][j], "/") - // } - // println() - //} - //println("upd") - //for _, u := range upd { - // println(u.String()) - //} - } rootHash, err = sdc.patriciaTrie.ProcessTree(ctx, sdc.updates, logPrefix) - println("calculated rootHash:", common.BytesToHash(rootHash).Hex()) if err != nil { return nil, err } diff --git a/erigon-lib/txpool/fetch.go b/erigon-lib/txpool/fetch.go index 2a2ccd3fbdd..adc8fe5fd6f 100644 --- a/erigon-lib/txpool/fetch.go +++ b/erigon-lib/txpool/fetch.go @@ -475,7 +475,6 @@ func (f *Fetch) handleStateChanges(ctx context.Context, client StateChangesClien func (f *Fetch) handleStateChangesRequest(ctx context.Context, req *remote.StateChangeBatch) error { var unwindTxs, unwindBlobTxs, minedTxs types2.TxSlots - f.logger.Error("[txpool.fetch] state changes") for _, change := range req.ChangeBatch { if change.Direction == remote.Direction_FORWARD { minedTxs.Resize(uint(len(change.Txs))) diff --git a/eth/backend.go b/eth/backend.go index dea35083b10..46601d60a08 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -457,7 +457,6 @@ func New(ctx context.Context, stack *node.Node, config *ethconfig.Config, logger var pi int // points to next port to be picked from refCfg.AllowedPorts for _, protocol := range p2pConfig.ProtocolVersion { - logger.Error("in sentry:", "protocol", protocol) cfg := p2pConfig cfg.NodeDatabase = filepath.Join(stack.Config().Dirs.Nodes, eth.ProtocolToString[protocol]) @@ -794,7 +793,6 @@ func New(ctx context.Context, stack *node.Node, config *ethconfig.Config, logger // 2) we cannot propose for block 1 regardless. if !config.DeprecatedTxPool.Disable { - println("connected to backend core") backend.txPoolFetch.ConnectCore() backend.txPoolFetch.ConnectSentries() var newTxsBroadcaster *txpool.NewSlotsStreams @@ -820,7 +818,6 @@ func New(ctx context.Context, stack *node.Node, config *ethconfig.Config, logger // will trigger the staged sync which will require headers and blocks to be available // in their respective cache in the download stage. If not found, it would cause a // liveness issue for the chain. - logger.Error("mined", "header", b.Header().Number.String()) if err := backend.sentriesClient.Hd.AddMinedHeader(b.Header()); err != nil { logger.Error("add mined block to header downloader", "err", err) } @@ -1255,7 +1252,6 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient miner.MiningConfig.Recommit = time.Second * 30 mineEvery := time.NewTicker(miner.MiningConfig.Recommit) - s.logger.Error("mine every loop", "every", miner.MiningConfig.Recommit.Seconds()) defer mineEvery.Stop() s.logger.Info("Starting to mine", "etherbase", eb) @@ -1281,7 +1277,6 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient if working || !hasWork { select { case stateChanges := <-stateChangeCh: - log.Warn("[dbg] stateChangeCh") block := stateChanges.BlockHeight s.logger.Debug("Start mining based on previous block", "block", block) // TODO - can do mining clean up here as we have previous @@ -1303,8 +1298,6 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient } hasWork = !(working || waiting.Load()) case err := <-errc: - log.Warn("[dbg] errc", "err", err) - working = false hasWork = false if errors.Is(err, libcommon.ErrStopped) { @@ -1317,21 +1310,16 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient return } } - if hasWork != false { - s.logger.Error("in loop of mining", "working", working, "hasWork", hasWork) - } + if !working && hasWork { - s.logger.Error("Started working") working = true hasWork = false mineEvery.Reset(miner.MiningConfig.Recommit) go func() { - s.logger.Error("come from goroutine in StartMining") err = stages2.MiningStep(ctx, db, mining, tmpDir, logger) waiting.Store(true) defer func() { - s.logger.Error("out of mining", "err", err) waiting.Store(false) }() diff --git a/eth/stagedsync/exec3.go b/eth/stagedsync/exec3.go index 4c5442f1248..c7ccc81e43a 100644 --- a/eth/stagedsync/exec3.go +++ b/eth/stagedsync/exec3.go @@ -182,10 +182,10 @@ func ExecV3(ctx context.Context, applyTx := txc.Tx useExternalTx := applyTx != nil + if !useExternalTx { if !parallel { var err error - println("new tx") applyTx, err = chainDb.BeginRw(ctx) //nolint if err != nil { return err @@ -206,7 +206,6 @@ func ExecV3(ctx context.Context, } pruneNonEssentials := cfg.prune.History.Enabled() && cfg.prune.History.PruneTo(execStage.BlockNumber) == execStage.BlockNumber - var err error inMemExec := txc.Doms != nil var doms *state2.SharedDomains @@ -214,7 +213,6 @@ func ExecV3(ctx context.Context, doms = txc.Doms } else { var err error - println("new sd") doms, err = state2.NewSharedDomains(applyTx, log.New()) // if we are behind the commitment, we can't execute anything // this can heppen if progress in domain is higher than progress in blocks @@ -910,7 +908,7 @@ Loop: t1, t2, t3 time.Duration ) - if ok, err := flushAndCheckCommitmentV3(ctx, b.HeaderNoCopy(), applyTx, doms, cfg, execStage, stageProgress, parallel, logger, u, inMemExec, isMining); err != nil { + if ok, err := flushAndCheckCommitmentV3(ctx, b, b.HeaderNoCopy(), applyTx, doms, cfg, execStage, stageProgress, parallel, logger, u, inMemExec, isMining); err != nil { return err } else if !ok { break Loop @@ -996,7 +994,7 @@ Loop: if isMining || u != nil && !u.HasUnwindPoint() { if b != nil { - _, err := flushAndCheckCommitmentV3(ctx, b.HeaderNoCopy(), applyTx, doms, cfg, execStage, stageProgress, parallel, logger, u, inMemExec, isMining) + _, err := flushAndCheckCommitmentV3(ctx, b, b.HeaderNoCopy(), applyTx, doms, cfg, execStage, stageProgress, parallel, logger, u, inMemExec, isMining) if err != nil { return err } @@ -1070,7 +1068,7 @@ func dumpPlainStateDebug(tx kv.RwTx, doms *state2.SharedDomains) { } // flushAndCheckCommitmentV3 - does write state to db and then check commitment -func flushAndCheckCommitmentV3(ctx context.Context, header *types.Header, applyTx kv.RwTx, doms *state2.SharedDomains, cfg ExecuteBlockCfg, e *StageState, maxBlockNum uint64, parallel bool, logger log.Logger, u Unwinder, inMemExec bool, isMining bool) (bool, error) { +func flushAndCheckCommitmentV3(ctx context.Context, b *types.Block, header *types.Header, applyTx kv.RwTx, doms *state2.SharedDomains, cfg ExecuteBlockCfg, e *StageState, maxBlockNum uint64, parallel bool, logger log.Logger, u Unwinder, inMemExec bool, isMining bool) (bool, error) { // E2 state root check was in another stage - means we did flush state even if state root will not match // And Unwind expecting it @@ -1102,7 +1100,6 @@ func flushAndCheckCommitmentV3(ctx context.Context, header *types.Header, applyT return false, fmt.Errorf("StateV3.Apply: %w", err) } if cfg.blockProduction { - println("HEADER ROOT IS2", header.Root.Hex(), common.BytesToHash(rh).Hex()) header.Root = common.BytesToHash(rh) return true, nil } diff --git a/eth/stagedsync/stage_mining_create_block.go b/eth/stagedsync/stage_mining_create_block.go index d575b8dd506..614b7f62994 100644 --- a/eth/stagedsync/stage_mining_create_block.go +++ b/eth/stagedsync/stage_mining_create_block.go @@ -140,7 +140,7 @@ func SpawnMiningCreateBlockStage(s *StageState, txc wrap.TxContainer, cfg Mining // If we do not have an etherbase, let's use the suggested one coinbase = cfg.blockBuilderParameters.SuggestedFeeRecipient } - logger.Error("in mining create", "last execution at", executionAt) + blockNum := executionAt + 1 localUncles, remoteUncles, err := readNonCanonicalHeaders(txc.Tx, blockNum, cfg.engine, coinbase, txPoolLocals) diff --git a/eth/stagedsync/stage_mining_exec.go b/eth/stagedsync/stage_mining_exec.go index ea9958e8bca..c83f0ab635d 100644 --- a/eth/stagedsync/stage_mining_exec.go +++ b/eth/stagedsync/stage_mining_exec.go @@ -251,7 +251,6 @@ func SpawnMiningExecStage(s *StageState, txc wrap.TxContainer, cfg MiningExecCfg current.Header.Root = libcommon.BytesToHash(rh) logger.Info("FinalizeBlockExecution", "block", current.Header.Number, "txn", current.Txs.Len(), "gas", current.Header.GasUsed, "receipt", current.Receipts.Len(), "payload", cfg.payloadId) - return nil } @@ -281,7 +280,6 @@ func getNextTransactions( return err } - log.Warn("[dbg] YieldBest", "executionAt", executionAt, "count", count) return nil }); err != nil { return nil, 0, err diff --git a/p2p/sentry/sentry_multi_client/broadcast.go b/p2p/sentry/sentry_multi_client/broadcast.go index 62d87e85543..702f8d2f84f 100644 --- a/p2p/sentry/sentry_multi_client/broadcast.go +++ b/p2p/sentry/sentry_multi_client/broadcast.go @@ -63,7 +63,6 @@ func (cs *MultiClient) PropagateNewBlockHashes(ctx context.Context, announces [] if err != nil { log.Error("propagateNewBlockHashes", "err", err) } - cs.logger.Error("sended msg") } } diff --git a/polygon/bor/bor.go b/polygon/bor/bor.go index bddda08811e..5cc0d912706 100644 --- a/polygon/bor/bor.go +++ b/polygon/bor/bor.go @@ -887,7 +887,7 @@ func (c *Bor) verifySeal(chain consensus.ChainHeaderReader, header *types.Header // header for running the transactions on top. func (c *Bor) Prepare(chain consensus.ChainHeaderReader, header *types.Header, state *state.IntraBlockState) error { // If the block isn't a checkpoint, cast a random vote (good enough for now) - header.Coinbase = libcommon.Address{} + //header.Coinbase = libcommon.Address{} header.Nonce = types.BlockNonce{} number := header.Number.Uint64() diff --git a/tests/bor/mining_test.go b/tests/bor/mining_test.go index 0a56651c04d..eaf216d0a88 100644 --- a/tests/bor/mining_test.go +++ b/tests/bor/mining_test.go @@ -59,11 +59,10 @@ func TestMiningBenchmark(t *testing.T) { // t.Skip("TODO: [e4] implement me") //} - log.Root().SetHandler(log.LvlFilterHandler(log.LvlDebug, log.StreamHandler(os.Stderr, log.TerminalFormat()))) + log.Root().SetHandler(log.LvlFilterHandler(log.LvlWarn, log.StreamHandler(os.Stderr, log.TerminalFormat()))) fdlimit.Raise(2048) genesis := helper.InitGenesis("./testdata/genesis_2val.json", 64, networkname.BorE2ETestChain2ValName) - var stacks []*node.Node var ethbackends []*eth.Ethereum var enodes []string diff --git a/turbo/shards/state_change_accumulator.go b/turbo/shards/state_change_accumulator.go index 602dd5c7d69..b7e6fef56f2 100644 --- a/turbo/shards/state_change_accumulator.go +++ b/turbo/shards/state_change_accumulator.go @@ -18,12 +18,9 @@ package shards import ( "context" - "github.com/erigontech/erigon-lib/common/dbg" - libcommon "github.com/erigontech/erigon-lib/common" "github.com/erigontech/erigon-lib/gointerfaces" remote "github.com/erigontech/erigon-lib/gointerfaces/remoteproto" - "github.com/erigontech/erigon-lib/log/v3" ) // Accumulator collects state changes in a form that can then be delivered to the RPC daemon @@ -66,7 +63,6 @@ func (a *Accumulator) SetStateID(stateID uint64) { // StartChange begins accumulation of changes for a new block func (a *Accumulator) StartChange(blockHeight uint64, blockHash libcommon.Hash, txs [][]byte, unwind bool) { - log.Warn("[dbg] StartChange", "blockHeight", blockHeight, "txs", len(txs), "stack", dbg.Stack()) a.changes = append(a.changes, &remote.StateChange{}) a.latestChange = a.changes[len(a.changes)-1] a.latestChange.BlockHeight = blockHeight diff --git a/turbo/stages/stageloop.go b/turbo/stages/stageloop.go index a5db09fd2b1..b81f67b6603 100644 --- a/turbo/stages/stageloop.go +++ b/turbo/stages/stageloop.go @@ -72,7 +72,6 @@ func StageLoop( hook *Hook, ) { defer close(waitForDone) - logger.Error("stageLoop start") if err := ProcessFrozenBlocks(ctx, db, blockReader, sync, hook, false); err != nil { if err != nil { if errors.Is(err, libcommon.ErrStopped) || errors.Is(err, context.Canceled) { From eadb02752415dd4de2fc027e4478d1dfeee57cfa Mon Sep 17 00:00:00 2001 From: JkLondon Date: Sat, 10 Aug 2024 20:11:38 +0400 Subject: [PATCH 34/53] small erasing --- eth/stagedsync/exec3.go | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/eth/stagedsync/exec3.go b/eth/stagedsync/exec3.go index 223c3578912..bc747ffd2f9 100644 --- a/eth/stagedsync/exec3.go +++ b/eth/stagedsync/exec3.go @@ -911,7 +911,7 @@ Loop: t1, t2, t3 time.Duration ) - if ok, err := flushAndCheckCommitmentV3(ctx, b, b.HeaderNoCopy(), applyTx, doms, cfg, execStage, stageProgress, parallel, logger, u, inMemExec, isMining); err != nil { + if ok, err := flushAndCheckCommitmentV3(ctx, b.HeaderNoCopy(), applyTx, doms, cfg, execStage, stageProgress, parallel, logger, u, inMemExec); err != nil { return err } else if !ok { break Loop @@ -997,7 +997,7 @@ Loop: if isMining || u != nil && !u.HasUnwindPoint() { if b != nil { - _, err := flushAndCheckCommitmentV3(ctx, b, b.HeaderNoCopy(), applyTx, doms, cfg, execStage, stageProgress, parallel, logger, u, inMemExec, isMining) + _, err := flushAndCheckCommitmentV3(ctx, b.HeaderNoCopy(), applyTx, doms, cfg, execStage, stageProgress, parallel, logger, u, inMemExec) if err != nil { return err } @@ -1071,7 +1071,7 @@ func dumpPlainStateDebug(tx kv.RwTx, doms *state2.SharedDomains) { } // flushAndCheckCommitmentV3 - does write state to db and then check commitment -func flushAndCheckCommitmentV3(ctx context.Context, b *types.Block, header *types.Header, applyTx kv.RwTx, doms *state2.SharedDomains, cfg ExecuteBlockCfg, e *StageState, maxBlockNum uint64, parallel bool, logger log.Logger, u Unwinder, inMemExec bool, isMining bool) (bool, error) { +func flushAndCheckCommitmentV3(ctx context.Context, header *types.Header, applyTx kv.RwTx, doms *state2.SharedDomains, cfg ExecuteBlockCfg, e *StageState, maxBlockNum uint64, parallel bool, logger log.Logger, u Unwinder, inMemExec bool) (bool, error) { // E2 state root check was in another stage - means we did flush state even if state root will not match // And Unwind expecting it @@ -1094,11 +1094,8 @@ func flushAndCheckCommitmentV3(ctx context.Context, b *types.Block, header *type if doms.BlockNum() != header.Number.Uint64() { panic(fmt.Errorf("%d != %d", doms.BlockNum(), header.Number.Uint64())) } - logPrefix := "mining" - if u != nil { - logPrefix = u.LogPrefix() - } - rh, err := doms.ComputeCommitment(ctx, true, header.Number.Uint64(), logPrefix) + + rh, err := doms.ComputeCommitment(ctx, true, header.Number.Uint64(), e.LogPrefix()) if err != nil { return false, fmt.Errorf("StateV3.Apply: %w", err) } From 2e20b32c0ad78de2cb7c04ad25be9b15a35b5de3 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Sat, 10 Aug 2024 20:12:40 +0400 Subject: [PATCH 35/53] small erasing --- turbo/stages/stageloop.go | 1 - 1 file changed, 1 deletion(-) diff --git a/turbo/stages/stageloop.go b/turbo/stages/stageloop.go index b81f67b6603..6bc9c8de511 100644 --- a/turbo/stages/stageloop.go +++ b/turbo/stages/stageloop.go @@ -249,7 +249,6 @@ func StageLoopIteration(ctx context.Context, db kv.RwDB, txc wrap.TxContainer, s // send notifications Now and do write to disks Later. // - Send Notifications: about new blocks, new receipts, state changes, etc... // - Prune(limited time)+Commit(sync). Write to disk happening here. - //logger.Error("in stageLooopIT", "canRunCycleInOneTransaction", canRunCycleInOneTransaction) if canRunCycleInOneTransaction && !externalTx { txc.Tx, err = db.BeginRwNosync(ctx) if err != nil { From c26367140ecdbdd58acc76b436635278bf525b5c Mon Sep 17 00:00:00 2001 From: JkLondon Date: Sat, 10 Aug 2024 20:24:19 +0400 Subject: [PATCH 36/53] lint fix --- eth/stagedsync/exec3.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/eth/stagedsync/exec3.go b/eth/stagedsync/exec3.go index bc747ffd2f9..e86ce3cfd56 100644 --- a/eth/stagedsync/exec3.go +++ b/eth/stagedsync/exec3.go @@ -1085,7 +1085,7 @@ func flushAndCheckCommitmentV3(ctx context.Context, header *types.Header, applyT } if header == nil { - return false, fmt.Errorf("header is nil") + return false, errors.New("header is nil") } if dbg.DiscardCommitment() { From fdaccbcd850bd482efc6573840117a191a0554c4 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Sun, 11 Aug 2024 17:47:58 +0400 Subject: [PATCH 37/53] small fixes --- cmd/state/exec3/state.go | 2 +- eth/stagedsync/exec3.go | 7 +++---- eth/stagedsync/stage_execute.go | 1 - eth/stagedsync/stage_headers.go | 7 ++----- eth/stagedsync/stage_mining_exec.go | 6 +----- polygon/bor/bor.go | 2 +- turbo/stages/headerdownload/header_algos.go | 1 - turbo/stages/stageloop.go | 13 +++---------- 8 files changed, 11 insertions(+), 28 deletions(-) diff --git a/cmd/state/exec3/state.go b/cmd/state/exec3/state.go index 5b07a693c97..b0bf094a752 100644 --- a/cmd/state/exec3/state.go +++ b/cmd/state/exec3/state.go @@ -128,7 +128,7 @@ func (rw *Worker) ResetTx(chainTx kv.Tx) { func (rw *Worker) Run() error { for txTask, ok := rw.in.Next(rw.ctx); ok; txTask, ok = rw.in.Next(rw.ctx) { - rw.RunTxTask(txTask, false) + rw.RunTxTask(txTask, rw.isMining) if err := rw.resultCh.Add(rw.ctx, txTask); err != nil { return err } diff --git a/eth/stagedsync/exec3.go b/eth/stagedsync/exec3.go index e86ce3cfd56..43855d9f580 100644 --- a/eth/stagedsync/exec3.go +++ b/eth/stagedsync/exec3.go @@ -810,8 +810,8 @@ Loop: blobGasUsed += txTask.Tx.GetBlobGas() } if txTask.Final { - checkReceipts := !cfg.vmConfig.StatelessExec && chainConfig.IsByzantium(txTask.BlockNum) && !cfg.vmConfig.NoReceipts // && !isMining - if txTask.BlockNum > 0 && !skipPostEvaluation { //Disable check for genesis. Maybe need somehow improve it in future - to satisfy TestExecutionSpec + checkReceipts := !cfg.vmConfig.StatelessExec && chainConfig.IsByzantium(txTask.BlockNum) && !cfg.vmConfig.NoReceipts + if txTask.BlockNum > 0 && !skipPostEvaluation { //Disable check for genesis. Maybe need somehow improve it in future - to satisfy TestExecutionSpec if err := core.BlockPostValidation(usedGas, blobGasUsed, checkReceipts, receipts, txTask.Header, isMining); err != nil { return fmt.Errorf("%w, txnIdx=%d, %v", consensus.ErrInvalidBlock, txTask.TxIndex, err) //same as in stage_exec.go } @@ -834,7 +834,6 @@ Loop: return err } if errors.Is(err, consensus.ErrInvalidBlock) { - fmt.Printf("[dbg] in unwindTo %T\n", applyTx) if u != nil { if err := u.UnwindTo(blockNum-1, BadBlock(header.Hash(), err), applyTx); err != nil { return err @@ -995,7 +994,7 @@ Loop: waitWorkers() } - if isMining || u != nil && !u.HasUnwindPoint() { + if u != nil && !u.HasUnwindPoint() { if b != nil { _, err := flushAndCheckCommitmentV3(ctx, b.HeaderNoCopy(), applyTx, doms, cfg, execStage, stageProgress, parallel, logger, u, inMemExec) if err != nil { diff --git a/eth/stagedsync/stage_execute.go b/eth/stagedsync/stage_execute.go index 36ef8cd03a6..cc0ffc7c1ac 100644 --- a/eth/stagedsync/stage_execute.go +++ b/eth/stagedsync/stage_execute.go @@ -305,7 +305,6 @@ func blocksReadAheadFunc(ctx context.Context, tx kv.Tx, cfg *ExecuteBlockCfg, bl } func UnwindExecutionStage(u *UnwindState, s *StageState, txc wrap.TxContainer, ctx context.Context, cfg ExecuteBlockCfg, logger log.Logger) (err error) { - fmt.Printf("unwind: %d -> %d, %T, %T\n", u.CurrentBlockNumber, u.UnwindPoint, txc.Tx, txc.Doms) if u.UnwindPoint >= s.BlockNumber { return nil } diff --git a/eth/stagedsync/stage_headers.go b/eth/stagedsync/stage_headers.go index 8e418be24b9..fb01de92919 100644 --- a/eth/stagedsync/stage_headers.go +++ b/eth/stagedsync/stage_headers.go @@ -173,11 +173,8 @@ func HeadersPOW(s *StageState, u Unwinder, ctx context.Context, tx kv.RwTx, cfg /* TEMP TESTING if localTd == nil { return fmt.Errorf("localTD is nil: %d, %x", startProgress, hash) - } - TEMP TESTING */ - if localTd == nil { - logger.Error("localTD is nil", "startProgress", startProgress, "hash", hash) - } + }*/ + headerInserter := headerdownload.NewHeaderInserter(logPrefix, localTd, startProgress, cfg.blockReader) cfg.hd.SetHeaderReader(&ChainReaderImpl{ config: &cfg.chainConfig, diff --git a/eth/stagedsync/stage_mining_exec.go b/eth/stagedsync/stage_mining_exec.go index c83f0ab635d..9744834013b 100644 --- a/eth/stagedsync/stage_mining_exec.go +++ b/eth/stagedsync/stage_mining_exec.go @@ -19,7 +19,6 @@ package stagedsync import ( "errors" "fmt" - "github.com/erigontech/erigon-lib/kv/membatchwithdb" state2 "github.com/erigontech/erigon-lib/state" "io" "math/big" @@ -137,11 +136,8 @@ func SpawnMiningExecStage(s *StageState, txc wrap.TxContainer, cfg MiningExecCfg yielded := mapset.NewSet[[32]byte]() var simStateReader state.StateReader var simStateWriter state.StateWriter - //simStateWriter = state.NewWriterV4(txc.Doms) - mb := membatchwithdb.NewMemoryBatch(txc.Tx, cfg.tmpdir, logger) - defer mb.Rollback() - sd, err := state2.NewSharedDomains(mb, logger) + sd, err := state2.NewSharedDomains(txc.Tx, logger) if err != nil { return err } diff --git a/polygon/bor/bor.go b/polygon/bor/bor.go index 6a3cf8c1815..c9afb52459d 100644 --- a/polygon/bor/bor.go +++ b/polygon/bor/bor.go @@ -898,7 +898,7 @@ func (c *Bor) verifySeal(chain consensus.ChainHeaderReader, header *types.Header // header for running the transactions on top. func (c *Bor) Prepare(chain consensus.ChainHeaderReader, header *types.Header, state *state.IntraBlockState) error { // If the block isn't a checkpoint, cast a random vote (good enough for now) - //header.Coinbase = libcommon.Address{} + //header.Coinbase = libcommon.Address{} TODO: not sure that it's right header.Nonce = types.BlockNonce{} number := header.Number.Uint64() diff --git a/turbo/stages/headerdownload/header_algos.go b/turbo/stages/headerdownload/header_algos.go index 324ad2e031d..32951140e59 100644 --- a/turbo/stages/headerdownload/header_algos.go +++ b/turbo/stages/headerdownload/header_algos.go @@ -395,7 +395,6 @@ func (hd *HeaderDownload) RequestMoreHeaders(currentTime time.Time) (*HeaderRequ var req *HeaderRequest hd.anchorTree.Ascend(func(anchor *Anchor) bool { - hd.logger.Error("in request more", "anch hash", anchor.parentHash.Hex()) if anchor.blockHeight == 0 { //has no parent return true } diff --git a/turbo/stages/stageloop.go b/turbo/stages/stageloop.go index 6bc9c8de511..be6af9a190b 100644 --- a/turbo/stages/stageloop.go +++ b/turbo/stages/stageloop.go @@ -32,7 +32,6 @@ import ( "github.com/erigontech/erigon-lib/direct" proto_downloader "github.com/erigontech/erigon-lib/gointerfaces/downloaderproto" "github.com/erigontech/erigon-lib/kv" - "github.com/erigontech/erigon-lib/kv/membatchwithdb" "github.com/erigontech/erigon-lib/kv/rawdbv3" "github.com/erigontech/erigon-lib/log/v3" "github.com/erigontech/erigon-lib/state" @@ -454,20 +453,14 @@ func MiningStep(ctx context.Context, db kv.RwDB, mining *stagedsync.Sync, tmpDir } }() // avoid crash because Erigon's core does many things - tx, err := db.BeginRo(ctx) + tx, err := db.BeginRw(ctx) if err != nil { return err } defer tx.Rollback() - var miningBatch kv.RwTx - - mb := membatchwithdb.NewMemoryBatch(tx, tmpDir, logger) - defer mb.Rollback() - miningBatch = mb - - txc := wrap.TxContainer{Tx: miningBatch} - sd, err := state.NewSharedDomains(mb, logger) + txc := wrap.TxContainer{Tx: tx} + sd, err := state.NewSharedDomains(tx, logger) if err != nil { return err } From e365544b9d240473a0960cfadaf0b5d643e744c6 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Sun, 11 Aug 2024 23:33:59 +0400 Subject: [PATCH 38/53] small fixes --- core/evm.go | 3 +-- eth/backend.go | 3 +-- eth/stagedsync/stage_mining_exec.go | 7 ++++--- 3 files changed, 6 insertions(+), 7 deletions(-) diff --git a/core/evm.go b/core/evm.go index 23d28f5d6cb..34dcd500316 100644 --- a/core/evm.go +++ b/core/evm.go @@ -40,8 +40,7 @@ func NewEVMBlockContext(header *types.Header, blockHashFunc func(n uint64) libco // If we don't have an explicit author (i.e. not mining), extract from the header var beneficiary libcommon.Address if author == nil { - beneficiary = header.Coinbase - //beneficiary, _ = engine.Author(header) // Ignore error, we're past header validation + beneficiary, _ = engine.Author(header) // Ignore error, we're past header validation } else { beneficiary = *author } diff --git a/eth/backend.go b/eth/backend.go index 3b8c9177b30..0bae4694839 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -1242,8 +1242,7 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient defer debug.LogPanic() defer close(s.waitForMiningStop) defer streamCancel() - //TODO: remove - miner.MiningConfig.Recommit = time.Second * 30 + mineEvery := time.NewTicker(miner.MiningConfig.Recommit) defer mineEvery.Stop() diff --git a/eth/stagedsync/stage_mining_exec.go b/eth/stagedsync/stage_mining_exec.go index 9744834013b..3e7f34596ee 100644 --- a/eth/stagedsync/stage_mining_exec.go +++ b/eth/stagedsync/stage_mining_exec.go @@ -108,9 +108,10 @@ func SpawnMiningExecStage(s *StageState, txc wrap.TxContainer, cfg MiningExecCfg stateReader = state.NewReaderV4(txc.Doms) ibs := state.New(stateReader) // Clique consensus needs forced author in the evm context - if cfg.chainConfig.Consensus == chain.CliqueConsensus { - execCfg.author = &cfg.miningState.MiningConfig.Etherbase - } + //if cfg.chainConfig.Consensus == chain.CliqueConsensus { + // execCfg.author = &cfg.miningState.MiningConfig.Etherbase + //} + execCfg.author = &cfg.miningState.MiningConfig.Etherbase // Create an empty block based on temporary copied state for // sealing in advance without waiting block execution finished. From 85e64d2e12073154b8d6862f6ffa67d12659163e Mon Sep 17 00:00:00 2001 From: JkLondon Date: Mon, 12 Aug 2024 12:45:50 +0400 Subject: [PATCH 39/53] small fixes --- eth/stagedsync/stage_mining_exec.go | 7 +++++-- tests/bor/mining_test.go | 2 +- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/eth/stagedsync/stage_mining_exec.go b/eth/stagedsync/stage_mining_exec.go index 3e7f34596ee..cca4a7109fd 100644 --- a/eth/stagedsync/stage_mining_exec.go +++ b/eth/stagedsync/stage_mining_exec.go @@ -19,6 +19,7 @@ package stagedsync import ( "errors" "fmt" + "github.com/erigontech/erigon-lib/kv/membatchwithdb" state2 "github.com/erigontech/erigon-lib/state" "io" "math/big" @@ -138,7 +139,9 @@ func SpawnMiningExecStage(s *StageState, txc wrap.TxContainer, cfg MiningExecCfg var simStateReader state.StateReader var simStateWriter state.StateWriter - sd, err := state2.NewSharedDomains(txc.Tx, logger) + mb := membatchwithdb.NewMemoryBatch(txc.Tx, cfg.tmpdir, logger) + defer mb.Close() + sd, err := state2.NewSharedDomains(mb, logger) if err != nil { return err } @@ -146,7 +149,7 @@ func SpawnMiningExecStage(s *StageState, txc wrap.TxContainer, cfg MiningExecCfg simStateWriter = state.NewWriterV4(sd) simStateReader = state.NewReaderV4(sd) - executionAt, err := s.ExecutionAt(txc.Tx) + executionAt, err := s.ExecutionAt(mb) if err != nil { return err } diff --git a/tests/bor/mining_test.go b/tests/bor/mining_test.go index eaf216d0a88..28ec1b76804 100644 --- a/tests/bor/mining_test.go +++ b/tests/bor/mining_test.go @@ -1,4 +1,4 @@ -////go:build integration +//go:build integration package bor From 393b73d228a3372af5ee8029e7c92663442d1091 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Tue, 13 Aug 2024 10:17:33 +0400 Subject: [PATCH 40/53] small fixes --- eth/stagedsync/stage_execute.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/eth/stagedsync/stage_execute.go b/eth/stagedsync/stage_execute.go index b66c04a320a..c3cee2da109 100644 --- a/eth/stagedsync/stage_execute.go +++ b/eth/stagedsync/stage_execute.go @@ -127,7 +127,7 @@ func StageExecuteBlocksCfg( historyV3: true, syncCfg: syncCfg, silkworm: silkworm, - applyWorker: exec3.NewWorker(nil, log.Root(), context.Background(), false, db, nil, blockReader, chainConfig, genesis, nil, engine, dirs), + applyWorker: exec3.NewWorker(nil, log.Root(), context.Background(), false, db, nil, blockReader, chainConfig, genesis, nil, engine, dirs, false), } } From 350b708cdc6bdf16d2ee1eb3cd7fa4a30797e18d Mon Sep 17 00:00:00 2001 From: JkLondon Date: Tue, 13 Aug 2024 11:18:05 +0400 Subject: [PATCH 41/53] add logging to integration --- tests/bor/mining_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/bor/mining_test.go b/tests/bor/mining_test.go index 28ec1b76804..2dbbb541223 100644 --- a/tests/bor/mining_test.go +++ b/tests/bor/mining_test.go @@ -59,7 +59,7 @@ func TestMiningBenchmark(t *testing.T) { // t.Skip("TODO: [e4] implement me") //} - log.Root().SetHandler(log.LvlFilterHandler(log.LvlWarn, log.StreamHandler(os.Stderr, log.TerminalFormat()))) + log.Root().SetHandler(log.LvlFilterHandler(log.LvlDebug, log.StreamHandler(os.Stderr, log.TerminalFormat()))) fdlimit.Raise(2048) genesis := helper.InitGenesis("./testdata/genesis_2val.json", 64, networkname.BorE2ETestChain2ValName) From 1abf7d480c33e905c303c01ec5057e3b8dca9911 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Tue, 13 Aug 2024 16:33:43 +0400 Subject: [PATCH 42/53] add logging to integration --- eth/backend.go | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/eth/backend.go b/eth/backend.go index 08965e28727..0b8b124c1a6 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -1250,9 +1250,6 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient hasWork := true // Start mining immediately errc := make(chan error, 1) - workCtx, workCancel := context.WithCancel(ctx) - defer workCancel() - for { // Only reset if some work was done previously as we'd like to rely // on the `miner.recommit` as backup. @@ -1288,6 +1285,7 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient case err := <-errc: working = false hasWork = false + logger.Debug("in errc", "err", err) if errors.Is(err, libcommon.ErrStopped) { return } @@ -1309,6 +1307,7 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient waiting.Store(true) defer func() { waiting.Store(false) + logger.Debug("Setted waiting to false", waiting.Load()) }() errc <- err @@ -1325,8 +1324,8 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient s.minedBlocks <- block } return - case <-workCtx.Done(): - errc <- workCtx.Err() + case <-ctx.Done(): + errc <- ctx.Err() return } } From e166af9985eb4fa2e39eee7a0bde39a87dafd95d Mon Sep 17 00:00:00 2001 From: JkLondon Date: Wed, 14 Aug 2024 13:49:33 +0400 Subject: [PATCH 43/53] fix hooks --- turbo/execution/eth1/ethereum_execution.go | 2 +- turbo/stages/stageloop.go | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/turbo/execution/eth1/ethereum_execution.go b/turbo/execution/eth1/ethereum_execution.go index 9ae6c69051e..a80240a993a 100644 --- a/turbo/execution/eth1/ethereum_execution.go +++ b/turbo/execution/eth1/ethereum_execution.go @@ -331,7 +331,7 @@ func (e *EthereumExecutionModule) Start(ctx context.Context) { e.semaphore.Acquire(ctx, 1) defer e.semaphore.Release(1) - if err := stages.ProcessFrozenBlocks(ctx, e.db, e.blockReader, e.executionPipeline, nil, false); err != nil { + if err := stages.ProcessFrozenBlocks(ctx, e.db, e.blockReader, e.executionPipeline, nil); err != nil { if !errors.Is(err, context.Canceled) { e.logger.Error("Could not start execution service", "err", err) } diff --git a/turbo/stages/stageloop.go b/turbo/stages/stageloop.go index be6af9a190b..e254efb9cf1 100644 --- a/turbo/stages/stageloop.go +++ b/turbo/stages/stageloop.go @@ -71,7 +71,7 @@ func StageLoop( hook *Hook, ) { defer close(waitForDone) - if err := ProcessFrozenBlocks(ctx, db, blockReader, sync, hook, false); err != nil { + if err := ProcessFrozenBlocks(ctx, db, blockReader, sync, hook); err != nil { if err != nil { if errors.Is(err, libcommon.ErrStopped) || errors.Is(err, context.Canceled) { println("what") @@ -147,14 +147,14 @@ func StageLoop( } // ProcessFrozenBlocks - withuot global rwtx -func ProcessFrozenBlocks(ctx context.Context, db kv.RwDB, blockReader services.FullBlockReader, sync *stagedsync.Sync, hook *Hook, inSync bool) error { +func ProcessFrozenBlocks(ctx context.Context, db kv.RwDB, blockReader services.FullBlockReader, sync *stagedsync.Sync, hook *Hook) error { sawZeroBlocksTimes := 0 initialCycle, firstCycle := true, true for { // run stages first time - it will download blocks if hook != nil { if err := db.View(ctx, func(tx kv.Tx) (err error) { - err = hook.BeforeRun(tx, inSync) + err = hook.BeforeRun(tx, false) return err }); err != nil { return err From 134913c60908e965872372c2807824a59bbf1074 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Wed, 14 Aug 2024 14:10:13 +0400 Subject: [PATCH 44/53] merged main --- eth/stagedsync/stage_mining_create_block.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/eth/stagedsync/stage_mining_create_block.go b/eth/stagedsync/stage_mining_create_block.go index 614b7f62994..1eaedad1168 100644 --- a/eth/stagedsync/stage_mining_create_block.go +++ b/eth/stagedsync/stage_mining_create_block.go @@ -195,7 +195,7 @@ func SpawnMiningCreateBlockStage(s *StageState, txc wrap.TxContainer, cfg Mining header.Extra = cfg.miner.MiningConfig.ExtraData logger.Info(fmt.Sprintf("[%s] Start mine", logPrefix), "block", executionAt+1, "baseFee", header.BaseFee, "gasLimit", header.GasLimit) - ibs := state.New(state.NewReaderV4(txc.Doms)) + ibs := state.New(state.NewReaderV3(txc.Doms)) if err = cfg.engine.Prepare(chain, header, ibs); err != nil { logger.Error("Failed to prepare header for mining", From 702d0859d4e81c8ac84c590dce5a737dc5cc048d Mon Sep 17 00:00:00 2001 From: JkLondon Date: Thu, 15 Aug 2024 13:39:05 +0400 Subject: [PATCH 45/53] fix --- Makefile | 5 +++-- tests/bor/mining_test.go | 1 + 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/Makefile b/Makefile index 8cba73a6a57..3672778d6ed 100644 --- a/Makefile +++ b/Makefile @@ -176,8 +176,9 @@ test: test-erigon-lib $(GOTEST) --timeout 10m -coverprofile=coverage.out ## test-integration: run integration tests with a 30m timeout -test-integration: test-erigon-lib - $(GOTEST) --timeout 240m -tags $(BUILD_TAGS),integration +test-integration: #test-erigon-lib //TODO: debug purposes only +## $(GOTEST) --timeout 240m -tags $(BUILD_TAGS),integration + $(GOTEST) -v --timeout 30m -tags $(BUILD_TAGS),integration ## lint-deps: install lint dependencies lint-deps: diff --git a/tests/bor/mining_test.go b/tests/bor/mining_test.go index 2dbbb541223..c613a27f185 100644 --- a/tests/bor/mining_test.go +++ b/tests/bor/mining_test.go @@ -58,6 +58,7 @@ func TestMiningBenchmark(t *testing.T) { //if config3.EnableHistoryV4InTest { // t.Skip("TODO: [e4] implement me") //} + t.Log("AAAAAAAAAAAAAAA_BBBBBBBBBBBBB") log.Root().SetHandler(log.LvlFilterHandler(log.LvlDebug, log.StreamHandler(os.Stderr, log.TerminalFormat()))) fdlimit.Raise(2048) From b8308077d263d3d734939f4a5698ca7706e2af3f Mon Sep 17 00:00:00 2001 From: JkLondon Date: Thu, 15 Aug 2024 14:32:20 +0400 Subject: [PATCH 46/53] fix --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 3672778d6ed..c812e51ea53 100644 --- a/Makefile +++ b/Makefile @@ -178,7 +178,7 @@ test: test-erigon-lib ## test-integration: run integration tests with a 30m timeout test-integration: #test-erigon-lib //TODO: debug purposes only ## $(GOTEST) --timeout 240m -tags $(BUILD_TAGS),integration - $(GOTEST) -v --timeout 30m -tags $(BUILD_TAGS),integration + $(GOTEST) -v --timeout 130m -tags $(BUILD_TAGS),integration ## lint-deps: install lint dependencies lint-deps: From 5c72991c13921b4bbbc932debbdfe1cff5dee31b Mon Sep 17 00:00:00 2001 From: JkLondon Date: Fri, 16 Aug 2024 13:06:57 +0400 Subject: [PATCH 47/53] fix --- eth/backend.go | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/eth/backend.go b/eth/backend.go index f13b7a49554..a4646b94e34 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -1280,10 +1280,9 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient defer func() { waiting.Store(false) logger.Debug("Setted waiting to false", waiting.Load()) + errc <- err }() - errc <- err - if err != nil { return } From 0b08db0427d545f0c2c3bb80961489ad4a0293d6 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Fri, 16 Aug 2024 15:30:12 +0400 Subject: [PATCH 48/53] fix --- Makefile | 2 +- eth/backend.go | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/Makefile b/Makefile index c812e51ea53..a3fcdd52171 100644 --- a/Makefile +++ b/Makefile @@ -178,7 +178,7 @@ test: test-erigon-lib ## test-integration: run integration tests with a 30m timeout test-integration: #test-erigon-lib //TODO: debug purposes only ## $(GOTEST) --timeout 240m -tags $(BUILD_TAGS),integration - $(GOTEST) -v --timeout 130m -tags $(BUILD_TAGS),integration + $(GOTEST) --timeout 130m -tags $(BUILD_TAGS),integration ## lint-deps: install lint dependencies lint-deps: diff --git a/eth/backend.go b/eth/backend.go index a4646b94e34..23629c34069 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -1255,7 +1255,7 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient } hasWork = !(working || waiting.Load()) case err := <-errc: - working = false + //working = false hasWork = false logger.Debug("in errc", "err", err) if errors.Is(err, libcommon.ErrStopped) { @@ -1274,6 +1274,7 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient hasWork = false mineEvery.Reset(miner.MiningConfig.Recommit) go func() { + logger.Debug("started mining step") err = stages2.MiningStep(ctx, db, mining, tmpDir, logger) waiting.Store(true) @@ -1281,6 +1282,7 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient waiting.Store(false) logger.Debug("Setted waiting to false", waiting.Load()) errc <- err + working = false }() if err != nil { From b1285dba76f1cdf981d895f494a8075ccb1fe6c1 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Fri, 16 Aug 2024 19:30:39 +0400 Subject: [PATCH 49/53] fix --- Makefile | 2 +- eth/stagedsync/sync.go | 7 ++++--- turbo/stages/stageloop.go | 2 +- 3 files changed, 6 insertions(+), 5 deletions(-) diff --git a/Makefile b/Makefile index a3fcdd52171..dc90bfb544e 100644 --- a/Makefile +++ b/Makefile @@ -178,7 +178,7 @@ test: test-erigon-lib ## test-integration: run integration tests with a 30m timeout test-integration: #test-erigon-lib //TODO: debug purposes only ## $(GOTEST) --timeout 240m -tags $(BUILD_TAGS),integration - $(GOTEST) --timeout 130m -tags $(BUILD_TAGS),integration + $(GOTEST) --timeout 30m -tags $(BUILD_TAGS),integration ## lint-deps: install lint dependencies lint-deps: diff --git a/eth/stagedsync/sync.go b/eth/stagedsync/sync.go index 6539801efd6..4f12da4b455 100644 --- a/eth/stagedsync/sync.go +++ b/eth/stagedsync/sync.go @@ -392,6 +392,7 @@ func (s *Sync) Run(db kv.RwDB, txc wrap.TxContainer, initialCycle, firstCycle bo if badBlockUnwind { // If there was a bad block, the current step needs to complete, to send the corresponding reply to the Consensus Layer // Otherwise, the staged sync will get stuck in the Headers stage with "Waiting for Consensus Layer..." + s.logger.Error("bad block unwind") break } @@ -403,12 +404,12 @@ func (s *Sync) Run(db kv.RwDB, txc wrap.TxContainer, initialCycle, firstCycle bo } if stage.Disabled || stage.Forward == nil { - s.logger.Trace(fmt.Sprintf("%s disabled. %s", stage.ID, stage.DisabledDescription)) - + //s.logger.Trace(fmt.Sprintf("%s disabled. %s", stage.ID, stage.DisabledDescription)) + s.logger.Error(fmt.Sprintf("%s disabled. %s", stage.ID, stage.DisabledDescription)) s.NextStage() continue } - + s.logger.Error("started runStage", "stage", stage.ID, "description", stage.Description) if err := s.runStage(stage, db, txc, initialCycle, firstCycle, badBlockUnwind); err != nil { return false, err } diff --git a/turbo/stages/stageloop.go b/turbo/stages/stageloop.go index 99bbaa3bf3b..e1a2566cf00 100644 --- a/turbo/stages/stageloop.go +++ b/turbo/stages/stageloop.go @@ -453,7 +453,7 @@ func MiningStep(ctx context.Context, db kv.RwDB, mining *stagedsync.Sync, tmpDir } defer sd.Close() txc.Doms = sd - + logger.Error("started mining run") if _, err = mining.Run(nil, txc, false /* firstCycle */, false); err != nil { return err } From 4e2ea387e0a02d9a42139fdf97b976e48c3e161c Mon Sep 17 00:00:00 2001 From: JkLondon Date: Fri, 16 Aug 2024 20:11:34 +0400 Subject: [PATCH 50/53] fix --- turbo/stages/stageloop.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/turbo/stages/stageloop.go b/turbo/stages/stageloop.go index e1a2566cf00..f9b461b1be2 100644 --- a/turbo/stages/stageloop.go +++ b/turbo/stages/stageloop.go @@ -438,14 +438,16 @@ func MiningStep(ctx context.Context, db kv.RwDB, mining *stagedsync.Sync, tmpDir if rec := recover(); rec != nil { err = fmt.Errorf("%+v, trace: %s", rec, dbg.Stack()) } + logger.Error("mining step end", "err", err) }() // avoid crash because Erigon's core does many things - + logger.Error("ms start") tx, err := db.BeginRw(ctx) if err != nil { return err } defer tx.Rollback() + logger.Error("miningstep tx begin") txc := wrap.TxContainer{Tx: tx} sd, err := state.NewSharedDomains(tx, logger) if err != nil { From a7c0fa2cb9d3cd21c78e873252d2377a948e6ee2 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Sat, 17 Aug 2024 00:07:53 +0400 Subject: [PATCH 51/53] fix --- turbo/stages/stageloop.go | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/turbo/stages/stageloop.go b/turbo/stages/stageloop.go index f9b461b1be2..2c123db67df 100644 --- a/turbo/stages/stageloop.go +++ b/turbo/stages/stageloop.go @@ -20,6 +20,7 @@ import ( "context" "errors" "fmt" + "github.com/erigontech/erigon-lib/kv/membatchwithdb" "runtime" "time" @@ -441,15 +442,18 @@ func MiningStep(ctx context.Context, db kv.RwDB, mining *stagedsync.Sync, tmpDir logger.Error("mining step end", "err", err) }() // avoid crash because Erigon's core does many things logger.Error("ms start") - tx, err := db.BeginRw(ctx) + tx, err := db.BeginRo(ctx) if err != nil { return err } defer tx.Rollback() + mb := membatchwithdb.NewMemoryBatch(tx, tmpDir, logger) + defer mb.Close() + logger.Error("miningstep tx begin") - txc := wrap.TxContainer{Tx: tx} - sd, err := state.NewSharedDomains(tx, logger) + txc := wrap.TxContainer{Tx: mb} + sd, err := state.NewSharedDomains(mb, logger) if err != nil { return err } From 5d5cf08cec961ab9a0637333f1c7347fd324b308 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Sat, 17 Aug 2024 01:09:11 +0400 Subject: [PATCH 52/53] fix --- Makefile | 5 ++--- eth/backend.go | 8 ++------ eth/stagedsync/sync.go | 5 +---- tests/bor/mining_test.go | 3 +-- turbo/stages/stageloop.go | 5 +---- 5 files changed, 7 insertions(+), 19 deletions(-) diff --git a/Makefile b/Makefile index dc90bfb544e..8cba73a6a57 100644 --- a/Makefile +++ b/Makefile @@ -176,9 +176,8 @@ test: test-erigon-lib $(GOTEST) --timeout 10m -coverprofile=coverage.out ## test-integration: run integration tests with a 30m timeout -test-integration: #test-erigon-lib //TODO: debug purposes only -## $(GOTEST) --timeout 240m -tags $(BUILD_TAGS),integration - $(GOTEST) --timeout 30m -tags $(BUILD_TAGS),integration +test-integration: test-erigon-lib + $(GOTEST) --timeout 240m -tags $(BUILD_TAGS),integration ## lint-deps: install lint dependencies lint-deps: diff --git a/eth/backend.go b/eth/backend.go index 23629c34069..ade2f57ef06 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -1249,15 +1249,14 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient s.logger.Debug("Start mining based on txpool notif") } case <-mineEvery.C: - log.Warn("[dbg] mineEvery", "working", working, "waiting", waiting.Load()) + //log.Warn("[dbg] mineEvery", "working", working, "waiting", waiting.Load()) if !(working || waiting.Load()) { s.logger.Debug("Start mining based on miner.recommit", "duration", miner.MiningConfig.Recommit) } hasWork = !(working || waiting.Load()) case err := <-errc: - //working = false + working = false hasWork = false - logger.Debug("in errc", "err", err) if errors.Is(err, libcommon.ErrStopped) { return } @@ -1274,15 +1273,12 @@ func (s *Ethereum) StartMining(ctx context.Context, db kv.RwDB, stateDiffClient hasWork = false mineEvery.Reset(miner.MiningConfig.Recommit) go func() { - logger.Debug("started mining step") err = stages2.MiningStep(ctx, db, mining, tmpDir, logger) waiting.Store(true) defer func() { waiting.Store(false) - logger.Debug("Setted waiting to false", waiting.Load()) errc <- err - working = false }() if err != nil { diff --git a/eth/stagedsync/sync.go b/eth/stagedsync/sync.go index 4f12da4b455..5f3b20ce3ed 100644 --- a/eth/stagedsync/sync.go +++ b/eth/stagedsync/sync.go @@ -392,7 +392,6 @@ func (s *Sync) Run(db kv.RwDB, txc wrap.TxContainer, initialCycle, firstCycle bo if badBlockUnwind { // If there was a bad block, the current step needs to complete, to send the corresponding reply to the Consensus Layer // Otherwise, the staged sync will get stuck in the Headers stage with "Waiting for Consensus Layer..." - s.logger.Error("bad block unwind") break } @@ -404,12 +403,10 @@ func (s *Sync) Run(db kv.RwDB, txc wrap.TxContainer, initialCycle, firstCycle bo } if stage.Disabled || stage.Forward == nil { - //s.logger.Trace(fmt.Sprintf("%s disabled. %s", stage.ID, stage.DisabledDescription)) - s.logger.Error(fmt.Sprintf("%s disabled. %s", stage.ID, stage.DisabledDescription)) + s.logger.Trace(fmt.Sprintf("%s disabled. %s", stage.ID, stage.DisabledDescription)) s.NextStage() continue } - s.logger.Error("started runStage", "stage", stage.ID, "description", stage.Description) if err := s.runStage(stage, db, txc, initialCycle, firstCycle, badBlockUnwind); err != nil { return false, err } diff --git a/tests/bor/mining_test.go b/tests/bor/mining_test.go index c613a27f185..28ec1b76804 100644 --- a/tests/bor/mining_test.go +++ b/tests/bor/mining_test.go @@ -58,9 +58,8 @@ func TestMiningBenchmark(t *testing.T) { //if config3.EnableHistoryV4InTest { // t.Skip("TODO: [e4] implement me") //} - t.Log("AAAAAAAAAAAAAAA_BBBBBBBBBBBBB") - log.Root().SetHandler(log.LvlFilterHandler(log.LvlDebug, log.StreamHandler(os.Stderr, log.TerminalFormat()))) + log.Root().SetHandler(log.LvlFilterHandler(log.LvlWarn, log.StreamHandler(os.Stderr, log.TerminalFormat()))) fdlimit.Raise(2048) genesis := helper.InitGenesis("./testdata/genesis_2val.json", 64, networkname.BorE2ETestChain2ValName) diff --git a/turbo/stages/stageloop.go b/turbo/stages/stageloop.go index 2c123db67df..73bbeb61217 100644 --- a/turbo/stages/stageloop.go +++ b/turbo/stages/stageloop.go @@ -439,9 +439,7 @@ func MiningStep(ctx context.Context, db kv.RwDB, mining *stagedsync.Sync, tmpDir if rec := recover(); rec != nil { err = fmt.Errorf("%+v, trace: %s", rec, dbg.Stack()) } - logger.Error("mining step end", "err", err) }() // avoid crash because Erigon's core does many things - logger.Error("ms start") tx, err := db.BeginRo(ctx) if err != nil { return err @@ -451,7 +449,6 @@ func MiningStep(ctx context.Context, db kv.RwDB, mining *stagedsync.Sync, tmpDir mb := membatchwithdb.NewMemoryBatch(tx, tmpDir, logger) defer mb.Close() - logger.Error("miningstep tx begin") txc := wrap.TxContainer{Tx: mb} sd, err := state.NewSharedDomains(mb, logger) if err != nil { @@ -459,7 +456,7 @@ func MiningStep(ctx context.Context, db kv.RwDB, mining *stagedsync.Sync, tmpDir } defer sd.Close() txc.Doms = sd - logger.Error("started mining run") + if _, err = mining.Run(nil, txc, false /* firstCycle */, false); err != nil { return err } From 1c57c4b51038e5d7c4e5e7f891578289dcf16866 Mon Sep 17 00:00:00 2001 From: JkLondon Date: Sat, 17 Aug 2024 01:24:28 +0400 Subject: [PATCH 53/53] fix --- polygon/bor/bor.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/polygon/bor/bor.go b/polygon/bor/bor.go index 399dd30ffb8..191efcca8b8 100644 --- a/polygon/bor/bor.go +++ b/polygon/bor/bor.go @@ -894,7 +894,7 @@ func (c *Bor) verifySeal(chain consensus.ChainHeaderReader, header *types.Header // header for running the transactions on top. func (c *Bor) Prepare(chain consensus.ChainHeaderReader, header *types.Header, state *state.IntraBlockState) error { // If the block isn't a checkpoint, cast a random vote (good enough for now) - //header.Coinbase = libcommon.Address{} TODO: not sure that it's right + header.Coinbase = libcommon.Address{} header.Nonce = types.BlockNonce{} number := header.Number.Uint64()