From 557cdb60a4b40416d4d5118fe1a9ae2506703148 Mon Sep 17 00:00:00 2001 From: Andrew Ashikhmin <34320705+yperbasis@users.noreply.github.com> Date: Thu, 31 Oct 2024 14:06:05 +0100 Subject: [PATCH] trace API: commit state changes from InitializeBlockExecution (#12559) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Prior to this PR in `callManyTransactions` (invoked by `trace_block`) changes made by `InitializeBlockExecution` were discarded, leading to issues like #12432. That was immaterial before since no much was happening at the beginning of a block. But that changed in Dencun with [EIP-4788](https://eips.ethereum.org/EIPS/eip-4788) – see `(s *Merge) Initialize`. --- turbo/jsonrpc/trace_adhoc.go | 64 ++++++++++++++++++-------------- turbo/jsonrpc/trace_filtering.go | 34 ++++++++++------- 2 files changed, 56 insertions(+), 42 deletions(-) diff --git a/turbo/jsonrpc/trace_adhoc.go b/turbo/jsonrpc/trace_adhoc.go index 86fc74af6d5..494fdc3562e 100644 --- a/turbo/jsonrpc/trace_adhoc.go +++ b/turbo/jsonrpc/trace_adhoc.go @@ -1125,17 +1125,33 @@ func (api *TraceAPIImpl) CallMany(ctx context.Context, calls json.RawMessage, pa return nil, fmt.Errorf("convert callParam to msg: %w", err) } } - results, _, err := api.doCallMany(ctx, dbtx, msgs, callParams, parentNrOrHash, nil, true /* gasBailout */, -1 /* all tx indices */, traceConfig) - return results, err + + chainConfig, err := api.chainConfig(ctx, dbtx) + if err != nil { + return nil, err + } + stateReader, err := rpchelper.CreateStateReader(ctx, dbtx, *parentNrOrHash, 0, api.filters, api.stateCache, api.historyV3(dbtx), chainConfig.ChainName) + if err != nil { + return nil, err + } + stateCache := shards.NewStateCache(32, 0 /* no limit */) // this cache living only during current RPC call, but required to store state writes + cachedReader := state.NewCachedReader(stateReader, stateCache) + noop := state.NewNoopWriter() + cachedWriter := state.NewCachedWriter(noop, stateCache) + ibs := state.New(cachedReader) + + return api.doCallMany(ctx, dbtx, stateReader, stateCache, cachedWriter, ibs, + msgs, callParams, parentNrOrHash, nil, true /* gasBailout */, -1 /* all tx indices */, traceConfig) } -func (api *TraceAPIImpl) doCallMany(ctx context.Context, dbtx kv.Tx, msgs []types.Message, callParams []TraceCallParam, - parentNrOrHash *rpc.BlockNumberOrHash, header *types.Header, gasBailout bool, txIndexNeeded int, - traceConfig *tracers.TraceConfig, -) ([]*TraceCallResult, *state.IntraBlockState, error) { +func (api *TraceAPIImpl) doCallMany(ctx context.Context, dbtx kv.Tx, stateReader state.StateReader, + stateCache *shards.StateCache, cachedWriter state.StateWriter, ibs *state.IntraBlockState, + msgs []types.Message, callParams []TraceCallParam, parentNrOrHash *rpc.BlockNumberOrHash, header *types.Header, + gasBailout bool, txIndexNeeded int, traceConfig *tracers.TraceConfig, +) ([]*TraceCallResult, error) { chainConfig, err := api.chainConfig(ctx, dbtx) if err != nil { - return nil, nil, err + return nil, err } engine := api.engine() @@ -1145,29 +1161,21 @@ func (api *TraceAPIImpl) doCallMany(ctx context.Context, dbtx kv.Tx, msgs []type } blockNumber, hash, _, err := rpchelper.GetBlockNumber(*parentNrOrHash, dbtx, api.filters) if err != nil { - return nil, nil, err - } - stateReader, err := rpchelper.CreateStateReader(ctx, dbtx, *parentNrOrHash, 0, api.filters, api.stateCache, api.historyV3(dbtx), chainConfig.ChainName) - if err != nil { - return nil, nil, err + return nil, err } - stateCache := shards.NewStateCache(32, 0 /* no limit */) // this cache living only during current RPC call, but required to store state writes - cachedReader := state.NewCachedReader(stateReader, stateCache) noop := state.NewNoopWriter() - cachedWriter := state.NewCachedWriter(noop, stateCache) - ibs := state.New(cachedReader) // TODO: can read here only parent header parentBlock, err := api.blockWithSenders(ctx, dbtx, hash, blockNumber) if err != nil { - return nil, nil, err + return nil, err } if parentBlock == nil { - return nil, nil, fmt.Errorf("parent block %d(%x) not found", blockNumber, hash) + return nil, fmt.Errorf("parent block %d(%x) not found", blockNumber, hash) } parentHeader := parentBlock.Header() if parentHeader == nil { - return nil, nil, fmt.Errorf("parent header %d(%x) not found", blockNumber, hash) + return nil, fmt.Errorf("parent header %d(%x) not found", blockNumber, hash) } // Setup context so it may be cancelled the call has completed @@ -1192,7 +1200,7 @@ func (api *TraceAPIImpl) doCallMany(ctx context.Context, dbtx kv.Tx, msgs []type for txIndex, msg := range msgs { if err := libcommon.Stopped(ctx.Done()); err != nil { - return nil, nil, err + return nil, err } var traceTypeTrace, traceTypeStateDiff, traceTypeVmTrace bool @@ -1206,7 +1214,7 @@ func (api *TraceAPIImpl) doCallMany(ctx context.Context, dbtx kv.Tx, msgs []type case TraceTypeVmTrace: traceTypeVmTrace = true default: - return nil, nil, fmt.Errorf("unrecognized trace type: %s", traceType) + return nil, fmt.Errorf("unrecognized trace type: %s", traceType) } } @@ -1216,7 +1224,7 @@ func (api *TraceAPIImpl) doCallMany(ctx context.Context, dbtx kv.Tx, msgs []type var ot OeTracer ot.config, err = parseOeTracerConfig(traceConfig) if err != nil { - return nil, nil, err + return nil, err } ot.compat = api.compatibility ot.r = traceResult @@ -1289,7 +1297,7 @@ func (api *TraceAPIImpl) doCallMany(ctx context.Context, dbtx kv.Tx, msgs []type execResult, err = core.ApplyMessage(evm, msg, gp, true /* refunds */, gasBailout /* gasBailout */) } if err != nil { - return nil, nil, fmt.Errorf("first run for txIndex %d error: %w", txIndex, err) + return nil, fmt.Errorf("first run for txIndex %d error: %w", txIndex, err) } chainRules := chainConfig.Rules(blockCtx.BlockNumber, blockCtx.Time) @@ -1298,21 +1306,21 @@ func (api *TraceAPIImpl) doCallMany(ctx context.Context, dbtx kv.Tx, msgs []type initialIbs := state.New(cloneReader) if !txFinalized { if err = ibs.FinalizeTx(chainRules, sd); err != nil { - return nil, nil, err + return nil, err } } sd.CompareStates(initialIbs, ibs) if err = ibs.CommitBlock(chainRules, cachedWriter); err != nil { - return nil, nil, err + return nil, err } } else { if !txFinalized { if err = ibs.FinalizeTx(chainRules, noop); err != nil { - return nil, nil, err + return nil, err } } if err = ibs.CommitBlock(chainRules, cachedWriter); err != nil { - return nil, nil, err + return nil, err } } if !traceTypeTrace { @@ -1326,7 +1334,7 @@ func (api *TraceAPIImpl) doCallMany(ctx context.Context, dbtx kv.Tx, msgs []type } } - return results, ibs, nil + return results, nil } // RawTransaction implements trace_rawTransaction. diff --git a/turbo/jsonrpc/trace_filtering.go b/turbo/jsonrpc/trace_filtering.go index 584bf7f446e..693b48c0808 100644 --- a/turbo/jsonrpc/trace_filtering.go +++ b/turbo/jsonrpc/trace_filtering.go @@ -932,23 +932,34 @@ func (api *TraceAPIImpl) callManyTransactions( } callParams := make([]TraceCallParam, 0, len(txs)) - reader, err := rpchelper.CreateHistoryStateReader(dbtx, blockNumber, txIndex, api.historyV3(dbtx), cfg.ChainName) - if err != nil { - return nil, nil, err + + parentHash := block.ParentHash() + parentNrOrHash := rpc.BlockNumberOrHash{ + BlockNumber: &parentNo, + BlockHash: &parentHash, + RequireCanonical: true, } - initialState := state.New(reader) + stateReader, err := rpchelper.CreateStateReader(ctx, dbtx, parentNrOrHash, 0, api.filters, api.stateCache, api.historyV3(dbtx), cfg.ChainName) if err != nil { return nil, nil, err } + stateCache := shards.NewStateCache(32, 0 /* no limit */) // this cache living only during current RPC call, but required to store state writes + cachedReader := state.NewCachedReader(stateReader, stateCache) + noop := state.NewNoopWriter() + cachedWriter := state.NewCachedWriter(noop, stateCache) + ibs := state.New(cachedReader) engine := api.engine() consensusHeaderReader := stagedsync.NewChainReaderImpl(cfg, dbtx, nil, nil) logger := log.New("trace_filtering") - err = core.InitializeBlockExecution(engine.(consensus.Engine), consensusHeaderReader, block.HeaderNoCopy(), cfg, initialState, logger) + err = core.InitializeBlockExecution(engine.(consensus.Engine), consensusHeaderReader, block.HeaderNoCopy(), cfg, ibs, logger) if err != nil { return nil, nil, err } + if err = ibs.CommitBlock(rules, cachedWriter); err != nil { + return nil, nil, err + } msgs := make([]types.Message, len(txs)) for i, tx := range txs { @@ -969,7 +980,7 @@ func (api *TraceAPIImpl) callManyTransactions( // gnosis might have a fee free account here if msg.FeeCap().IsZero() && engine != nil { syscall := func(contract common.Address, data []byte) ([]byte, error) { - return core.SysCallContract(contract, data, cfg, initialState, header, engine, true /* constCall */) + return core.SysCallContract(contract, data, cfg, ibs, header, engine, true /* constCall */) } msg.SetIsFree(engine.IsServiceTransaction(msg.From(), syscall)) } @@ -984,20 +995,15 @@ func (api *TraceAPIImpl) callManyTransactions( msgs[i] = msg } - parentHash := block.ParentHash() - - traces, lastState, cmErr := api.doCallMany(ctx, dbtx, msgs, callParams, &rpc.BlockNumberOrHash{ - BlockNumber: &parentNo, - BlockHash: &parentHash, - RequireCanonical: true, - }, header, gasBailOut /* gasBailout */, txIndex, traceConfig) + traces, cmErr := api.doCallMany(ctx, dbtx, stateReader, stateCache, cachedWriter, ibs, msgs, callParams, + &parentNrOrHash, header, gasBailOut /* gasBailout */, txIndex, traceConfig) if cmErr != nil { return nil, nil, cmErr } syscall := func(contract common.Address, data []byte) ([]byte, error) { - return core.SysCallContract(contract, data, cfg, lastState, header, engine, false /* constCall */) + return core.SysCallContract(contract, data, cfg, ibs, header, engine, false /* constCall */) } return traces, syscall, nil