[DO NOT MERGE] Historical re-execution for debugging Chiado issue

cmd/utils/app/backtest_commitment_cmd.go

@@ -107,7 +107,7 @@ func doBacktestCommitment(ctx context.Context, args backtestCommitmentArgs, logg
 	defer chainDB.Close()
 	chainConfig := fromdb.ChainConfig(chainDB)
 	cfg := ethconfig.NewSnapCfg(false, true, true, chainConfig.ChainName)
-	snaps, clean, err := openSnaps(ctx, cfg, dirs, chainDB, logger)
+	snaps, clean, err := OpenSnaps(ctx, cfg, dirs, chainDB, logger)
 	if err != nil {
 		return err
 	}

cmd/utils/app/snapshots_cmd.go

@@ -824,7 +824,7 @@ func doRollbackSnapshotsToBlock(ctx context.Context, blockNum uint64, prompt boo
 	defer chainDB.Close()
 	chainConfig := fromdb.ChainConfig(chainDB)
 	cfg := ethconfig.NewSnapCfg(false, true, true, chainConfig.ChainName)
-	res, clean, err := openSnaps(ctx, cfg, dirs, chainDB, logger)
+	res, clean, err := OpenSnaps(ctx, cfg, dirs, chainDB, logger)
 	br, agg := res.BlockRetire, res.Aggregator
 	if err != nil {
 		return err
@@ -977,7 +977,7 @@ func doDebugKey(cliCtx *cli.Context) error {
 	chainConfig := fromdb.ChainConfig(chainDB)
 	cfg := ethconfig.NewSnapCfg(false, true, true, chainConfig.ChainName)
 
-	res, clean, err := openSnaps(ctx, cfg, dirs, chainDB, logger)
+	res, clean, err := OpenSnaps(ctx, cfg, dirs, chainDB, logger)
 	agg := res.Aggregator
 	if err != nil {
 		return err
@@ -1049,7 +1049,7 @@ func doIntegrity(cliCtx *cli.Context) error {
 	chainConfig := fromdb.ChainConfig(chainDB)
 	cfg := ethconfig.NewSnapCfg(false, true, true, chainConfig.ChainName)
 
-	res, clean, err := openSnaps(ctx, cfg, dirs, chainDB, logger)
+	res, clean, err := OpenSnaps(ctx, cfg, dirs, chainDB, logger)
 	borSnaps, blockRetire, agg := res.BorSnaps, res.BlockRetire, res.Aggregator
 	if err != nil {
 		return err
@@ -1162,7 +1162,7 @@ func doCheckCommitmentHistAtBlk(cliCtx *cli.Context, logger log.Logger) error {
 	defer chainDB.Close()
 	chainConfig := fromdb.ChainConfig(chainDB)
 	cfg := ethconfig.NewSnapCfg(false /*keepBlocks*/, true /*produceE2*/, true /*produceE3*/, chainConfig.ChainName)
-	res, clean, err := openSnaps(ctx, cfg, dirs, chainDB, logger)
+	res, clean, err := OpenSnaps(ctx, cfg, dirs, chainDB, logger)
 	blockRetire, agg := res.BlockRetire, res.Aggregator
 	if err != nil {
 		return err
@@ -1187,7 +1187,7 @@ func doCheckCommitmentHistAtBlkRange(cliCtx *cli.Context, logger log.Logger) err
 	defer chainDB.Close()
 	chainConfig := fromdb.ChainConfig(chainDB)
 	cfg := ethconfig.NewSnapCfg(false /*keepBlocks*/, true /*produceE2*/, true /*produceE3*/, chainConfig.ChainName)
-	res, clean, err := openSnaps(ctx, cfg, dirs, chainDB, logger)
+	res, clean, err := OpenSnaps(ctx, cfg, dirs, chainDB, logger)
 	blockRetire, agg := res.BlockRetire, res.Aggregator
 	if err != nil {
 		return err
@@ -1754,7 +1754,7 @@ func doBlkTxNum(cliCtx *cli.Context) error {
 	chainConfig := fromdb.ChainConfig(chainDB)
 	cfg := ethconfig.NewSnapCfg(false, true, true, chainConfig.ChainName)
 
-	res, clean, err := openSnaps(ctx, cfg, dirs, chainDB, logger)
+	res, clean, err := OpenSnaps(ctx, cfg, dirs, chainDB, logger)
 	br, agg := res.BlockRetire, res.Aggregator
 	if err != nil {
 		return err
@@ -1965,7 +1965,7 @@ func doIndicesCommand(cliCtx *cli.Context, dirs datadir.Dirs) error {
 	chainConfig := fromdb.ChainConfig(chainDB)
 	cfg := ethconfig.NewSnapCfg(false, true, true, chainConfig.ChainName)
 
-	res, clean, err := openSnaps(ctx, cfg, dirs, chainDB, logger)
+	res, clean, err := OpenSnaps(ctx, cfg, dirs, chainDB, logger)
 	caplinSnaps, caplinStateSnaps, br, agg := res.CaplinSnaps, res.CaplinStateSnaps, res.BlockRetire, res.Aggregator
 	if err != nil {
 		return err
@@ -2006,7 +2006,7 @@ func doLS(cliCtx *cli.Context, dirs datadir.Dirs) error {
 	defer chainDB.Close()
 	cfg := ethconfig.NewSnapCfg(false, true, true, fromdb.ChainConfig(chainDB).ChainName)
 
-	res, clean, err := openSnaps(ctx, cfg, dirs, chainDB, logger)
+	res, clean, err := OpenSnaps(ctx, cfg, dirs, chainDB, logger)
 	blockSnaps, borSnaps, caplinSnaps, agg := res.BlockSnaps, res.BorSnaps, res.CaplinSnaps, res.Aggregator
 	if err != nil {
 		return err
@@ -2031,7 +2031,7 @@ type OpenSnapsResult struct {
 	ForkAgg          *state.ForkableAgg
 }
 
-func openSnaps(ctx context.Context, cfg ethconfig.BlocksFreezing, dirs datadir.Dirs, chainDB kv.RwDB, logger log.Logger) (
+func OpenSnaps(ctx context.Context, cfg ethconfig.BlocksFreezing, dirs datadir.Dirs, chainDB kv.RwDB, logger log.Logger) (
 	res OpenSnapsResult,
 	clean func(),
 	err error,
@@ -2306,7 +2306,7 @@ func doRemoveOverlap(cliCtx *cli.Context, dirs datadir.Dirs) error {
 	cfg := ethconfig.NewSnapCfg(false, true, true, chainConfig.ChainName)
 	ctx := cliCtx.Context
 
-	res, clean, err := openSnaps(ctx, cfg, dirs, db, logger)
+	res, clean, err := OpenSnaps(ctx, cfg, dirs, db, logger)
 	agg := res.Aggregator
 	if err != nil {
 		return err
@@ -2437,7 +2437,7 @@ func doUnmerge(cliCtx *cli.Context, dirs datadir.Dirs) error {
 	defer chainDB.Close()
 	chainConfig := fromdb.ChainConfig(chainDB)
 	cfg := ethconfig.NewSnapCfg(false, true, true, chainConfig.ChainName)
-	res, clean, err := openSnaps(ctx, cfg, dirs, chainDB, logger)
+	res, clean, err := OpenSnaps(ctx, cfg, dirs, chainDB, logger)
 	br := res.BlockRetire
 	if err != nil {
 		return err
@@ -2464,7 +2464,7 @@ func doRetireCommand(cliCtx *cli.Context, dirs datadir.Dirs) error {
 	chainConfig := fromdb.ChainConfig(db)
 	cfg := ethconfig.NewSnapCfg(false, true, true, chainConfig.ChainName)
 
-	res, clean, err := openSnaps(ctx, cfg, dirs, db, logger)
+	res, clean, err := OpenSnaps(ctx, cfg, dirs, db, logger)
 	caplinSnaps, br, agg := res.CaplinSnaps, res.BlockRetire, res.Aggregator
 	if err != nil {
 		return err

cmd/utils/app/squeeze_cmd.go

@@ -90,7 +90,7 @@ func squeezeCommitment(ctx context.Context, dirs datadir.Dirs, logger log.Logger
 	defer db.Close()
 	cfg := ethconfig.NewSnapCfg(false, true, true, fromdb.ChainConfig(db).ChainName)
 
-	res, clean, err := openSnaps(ctx, cfg, dirs, db, logger)
+	res, clean, err := OpenSnaps(ctx, cfg, dirs, db, logger)
 	agg := res.Aggregator
 	if err != nil {
 		return err
@@ -122,7 +122,7 @@ func squeezeStorage(ctx context.Context, dirs datadir.Dirs, logger log.Logger) e
 	db := dbCfg(dbcfg.ChainDB, dirs.Chaindata).MustOpen()
 	defer db.Close()
 	cfg := ethconfig.NewSnapCfg(false, true, true, fromdb.ChainConfig(db).ChainName)
-	res, clean, err := openSnaps(ctx, cfg, dirs, db, logger)
+	res, clean, err := OpenSnaps(ctx, cfg, dirs, db, logger)
 	agg := res.Aggregator
 	if err != nil {
 		return err
@@ -233,7 +233,7 @@ func squeezeBlocks(ctx context.Context, dirs datadir.Dirs, logger log.Logger) er
 	chainConfig := fromdb.ChainConfig(db)
 	cfg := ethconfig.NewSnapCfg(false, true, true, chainConfig.ChainName)
 
-	res, clean, err := openSnaps(ctx, cfg, dirs, db, logger)
+	res, clean, err := OpenSnaps(ctx, cfg, dirs, db, logger)
 	br := res.BlockRetire
 	if err != nil {
 		return err

execution/exec/backtester/back_test.go

@@ -0,0 +1,195 @@
+package exec_backtester
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"golang.org/x/sync/semaphore"
+
+	"github.com/erigontech/erigon/cmd/hack/tool/fromdb"
+	"github.com/erigontech/erigon/cmd/utils/app"
+	"github.com/erigontech/erigon/common/log/v3"
+	"github.com/erigontech/erigon/db/consensuschain"
+	"github.com/erigontech/erigon/db/datadir"
+	"github.com/erigontech/erigon/db/kv"
+	"github.com/erigontech/erigon/db/kv/dbcfg"
+	"github.com/erigontech/erigon/db/kv/mdbx"
+	"github.com/erigontech/erigon/db/kv/order"
+	"github.com/erigontech/erigon/db/kv/temporal"
+	"github.com/erigontech/erigon/db/services"
+	"github.com/erigontech/erigon/execution/chain"
+	"github.com/erigontech/erigon/execution/protocol"
+	"github.com/erigontech/erigon/execution/state"
+	"github.com/erigontech/erigon/execution/tests/testutil"
+	"github.com/erigontech/erigon/execution/types"
+	"github.com/erigontech/erigon/execution/types/accounts"
+	"github.com/erigontech/erigon/execution/vm"
+	"github.com/erigontech/erigon/node/ethconfig"
+	"github.com/erigontech/erigon/node/rulesconfig"
+)
+
+func dbCfg(label kv.Label, path string, logger log.Logger) mdbx.MdbxOpts {
+	const ThreadsLimit = 9_000
+	limiterB := semaphore.NewWeighted(ThreadsLimit)
+	return mdbx.New(label, logger).Path(path).
+		RoTxsLimiter(limiterB).
+		Accede(true) // integration tool: open db without creation and without blocking erigon
+}
+
+func storedChanges(tx kv.TemporalTx, fromTxNum uint64, txnIndex int) (map[string]([]byte), error) {
+	changes := make(map[string]([]byte))
+
+	it, err := tx.HistoryRange(kv.AccountsDomain, int(fromTxNum+uint64(txnIndex+1)), int(fromTxNum+uint64(txnIndex+2)), order.Asc, -1)
+	if err != nil {
+		return changes, err
+	}
+	//defer it.Close()
+	for it.HasNext() {
+		key, _, err := it.Next()
+		if err != nil {
+			return changes, err
+		}
+		val, ok, err := tx.GetAsOf(kv.AccountsDomain, key, fromTxNum+uint64(txnIndex+2))
+		if err != nil {
+			return changes, err
+		}
+		if !ok {
+			return changes, errors.New("account val not found")
+		}
+		changes[string(key)] = val
+	}
+
+	it, err = tx.HistoryRange(kv.StorageDomain, int(fromTxNum+uint64(txnIndex+1)), int(fromTxNum+uint64(txnIndex+2)), order.Asc, -1)
+	if err != nil {
+		return changes, err
+	}
+	//defer it.Close()
+	for it.HasNext() {
+		key, _, err := it.Next()
+		if err != nil {
+			return changes, err
+		}
+		val, ok, err := tx.GetAsOf(kv.StorageDomain, key, fromTxNum+uint64(txnIndex+2))
+		if err != nil {
+			return changes, err
+		}
+		if !ok {
+			return changes, errors.New("storage val not found")
+		}
+		changes[string(key)] = val
+	}
+
+	return changes, err
+}
+
+// Use HistoricalTraceWorker instead???
+func reExecutedChanges(ctx context.Context, tx kv.TemporalTx, blockReader services.FullBlockReader, chainConfig *chain.Config, block *types.Block, fromTxNum uint64, txnIndex int, logger log.Logger, receipts types.Receipts) (map[string]([]byte), error) {
+	header := block.Header()
+	stateReader := state.NewHistoryReaderV3(tx, fromTxNum+uint64(txnIndex+1))
+	ibs := state.New(stateReader)
+	engine := rulesconfig.CreateRulesEngineBareBones(ctx, chainConfig, logger)
+	blockContext := protocol.NewEVMBlockContext(header, protocol.GetHashFn(header, nil), engine, accounts.NilAddress, chainConfig)
+	rules := blockContext.Rules(chainConfig)
+	vmCfg := vm.Config{}
+
+	if txnIndex == -1 { // beginning of the block
+		syscall := func(contract accounts.Address, data []byte, ibs *state.IntraBlockState, header *types.Header, constCall bool) ([]byte, error) {
+			return protocol.SysCallContract(contract, data, chainConfig, ibs, header, engine, constCall /* constCall */, vmCfg)
+		}
+		chainReader := consensuschain.NewReader(chainConfig, tx, blockReader, logger)
+		err := engine.Initialize(chainConfig, chainReader, header, ibs, syscall, logger, nil /* hooks */)
+		if err != nil {
+			return nil, err
+		}
+		noop := state.NewNoopWriter()
+		err = ibs.FinalizeTx(rules, noop)
+		if err != nil {
+			return nil, err
+		}
+	} else if txnIndex == len(block.Transactions()) { // end of the block
+		ibs.SetTxContext(block.NumberU64(), txnIndex)
+		syscall := func(contract accounts.Address, data []byte) ([]byte, error) {
+			return protocol.SysCallContract(contract, data, chainConfig, ibs, header, engine, false /* constCall */, vmCfg)
+		}
+		chainReader := consensuschain.NewReader(chainConfig, tx, blockReader, logger)
+		_, err := engine.Finalize(
+			chainConfig, header, ibs, block.Transactions(), block.Uncles(),
+			receipts, block.Withdrawals(), chainReader, syscall, false, logger)
+		if err != nil {
+			return nil, err
+		}
+	} else { // normal transaction
+		txn := block.Transactions()[txnIndex]
+		gasPool := protocol.NewGasPool(txn.GetGasLimit(), txn.GetBlobGas())
+		ibs.SetTxContext(block.NumberU64(), txnIndex)
+		signer := types.MakeSigner(chainConfig, block.NumberU64(), header.Time)
+		msg, err := txn.AsMessage(*signer, header.BaseFee, rules)
+		if err != nil {
+			return nil, err
+		}
+		txnContext := protocol.NewEVMTxContext(msg)
+		evm := vm.NewEVM(blockContext, txnContext, ibs, chainConfig, vmCfg)
+		_, err = protocol.ApplyMessage(evm, msg, gasPool, true /* refunds */, false /* gasBailout */, engine)
+		if err != nil {
+			return nil, err
+		}
+		ibs.SoftFinalise()
+		logs := ibs.GetRawLogs(txnIndex)
+		receipts = append(receipts, &types.Receipt{Logs: logs})
+	}
+
+	stateWriter := testutil.NewMapWriter()
+	err := ibs.MakeWriteSet(rules, stateWriter)
+	if err != nil {
+		return nil, err
+	}
+	return stateWriter.Changes, err
+}
+
+func TestReExecution(t *testing.T) {
+	// https://github.com/erigontech/erigon/issues/18276
+	dataDir := "/Users/andrew/Library/Erigon/chiado_backup"
+	blockNum := uint64(19366160)
+
+	dirs, _, err := datadir.New(dataDir).MustFlock()
+	require.NoError(t, err)
+	// defer func() {
+	// 	err := l.Unlock()
+	// 	require.NoError(t, err)
+	// }()
+	logger := log.New()
+	chainDB := dbCfg(dbcfg.ChainDB, dirs.Chaindata, logger).MustOpen()
+	//defer chainDB.Close()
+	chainConfig := fromdb.ChainConfig(chainDB)
+	cfg := ethconfig.NewSnapCfg(false, true, true, chainConfig.ChainName)
+	ctx := context.TODO()
+	snaps, _, err := app.OpenSnaps(ctx, cfg, dirs, chainDB, logger)
+	require.NoError(t, err)
+	//	defer clean()
+	blockReader, _ := snaps.BlockRetire.IO()
+	db, err := temporal.New(chainDB, snaps.Aggregator)
+	require.NoError(t, err)
+	//	defer db.Close()
+
+	tnr := blockReader.TxnumReader(ctx)
+	tx, err := db.BeginTemporalRo(ctx)
+	require.NoError(t, err)
+	fromTxNum, err := tnr.Min(tx, blockNum)
+	require.NoError(t, err)
+
+	block, err := blockReader.BlockByNumber(ctx, tx, blockNum)
+	require.NoError(t, err)
+
+	receipts := make([]*types.Receipt, 0, len(block.Transactions()))
+	for txnIndex := -1; txnIndex <= len(block.Transactions()); txnIndex++ {
+		changesInDb, err := storedChanges(tx, fromTxNum, txnIndex)
+		require.NoError(t, err)
+		reExecChanges, err := reExecutedChanges(ctx, tx, blockReader, chainConfig, block, fromTxNum, txnIndex, logger, receipts)
+		require.NoError(t, err)
+		assert.Equal(t, changesInDb, reExecChanges, fmt.Sprintf("mismatch at %d", txnIndex))
+	}
+}

execution/exec/historical_trace_worker.go

@@ -202,7 +202,7 @@ func (rw *HistoricalTraceWorker) RunTxTask(txTask *TxTask) *TxResult {
 	default:
 		tracer := calltracer.NewCallTracer(nil)
 		result.Err = func() error {
-			rw.taskGasPool.Reset(txTask.Tx().GetGasLimit(), cc.GetMaxBlobGasPerBlock(header.Time))
+			rw.taskGasPool.Reset(txTask.Tx().GetGasLimit(), txTask.Tx().GetBlobGas())
 			rw.vmCfg.Tracer = tracer.Tracer().Hooks
 			ibs.SetTxContext(txTask.BlockNumber(), txTask.TxIndex)
 			txn := txTask.Tx()
@@ -661,6 +661,7 @@ func CustomTraceMapReduce(ctx context.Context, fromBlock, toBlock uint64, consum
 	return nil
 }
 
+// TODO(yperbasis): why is it called "WithSenders"?
 func BlockWithSenders(ctx context.Context, db kv.RoDB, tx kv.Tx, blockReader services.BlockReader, blockNum uint64) (b *types.Block, err error) {
 	select {
 	case <-ctx.Done():