Skip to content

Commit

Permalink
trace API: commit state changes from InitializeBlockExecution (#12559)
Browse files Browse the repository at this point in the history 
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`.
  • Loading branch information
@yperbasis
yperbasis committed Oct 31, 2024
1 parent edf4149 commit 557cdb6
Show file tree
Hide file tree
Showing 2 changed files with 56 additions and 42 deletions.
64 changes: 36 additions & 28 deletions turbo/jsonrpc/trace_adhoc.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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()

Expand All @@ -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
Expand All @@ -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
Expand All @@ -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)
}
}

Expand All @@ -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
Expand Down Expand Up @@ -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)
Expand All @@ -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 {
Expand All @@ -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.
Expand Down
34 changes: 20 additions & 14 deletions turbo/jsonrpc/trace_filtering.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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 {
Expand All @@ -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))
}
Expand All @@ -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
Expand Down

0 comments on commit 557cdb6

Please sign in to comment.