eth/tracers: add multiplexing tracer

eth/tracers/api.go

@@ -908,6 +908,8 @@ func (api *API) traceTx(ctx context.Context, message core.Message, txctx *Contex
  return nil, err
  }
  }
+ vmenv := vm.NewEVM(vmctx, txContext, statedb, api.backend.ChainConfig(), vm.Config{Debug: true, Tracer: tracer, NoBaseFee: true})
+
  // Define a meaningful timeout of a single transaction trace
  if config.Timeout != nil {
  if timeout, err = time.ParseDuration(*config.Timeout); err != nil {
@@ -919,13 +921,13 @@ func (api *API) traceTx(ctx context.Context, message core.Message, txctx *Contex
  <-deadlineCtx.Done()
  if errors.Is(deadlineCtx.Err(), context.DeadlineExceeded) {
  tracer.Stop(errors.New("execution timeout"))
+ // Stop evm execution. Note cancellation is not necessarily immediate.
+ vmenv.Cancel()
  }
  }()
  defer cancel()
 
  // Run the transaction with tracing enabled.
- vmenv := vm.NewEVM(vmctx, txContext, statedb, api.backend.ChainConfig(), vm.Config{Debug: true, Tracer: tracer, NoBaseFee: true})
-
  if posa, ok := api.backend.Engine().(consensus.PoSA); ok && message.From() == vmctx.Coinbase &&
  posa.IsSystemContract(message.To()) && message.GasPrice().Cmp(big.NewInt(0)) == 0 {
  balance := statedb.GetBalance(consensus.SystemAddress)

eth/tracers/logger/logger.go

@@ -150,7 +150,6 @@ func (l *StructLogger) CaptureStart(env *vm.EVM, from common.Address, to common.
 func (l *StructLogger) CaptureState(pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, rData []byte, depth int, err error) {
  // If tracing was interrupted, set the error and stop
  if atomic.LoadUint32(&l.interrupt) > 0 {
- l.env.Cancel()
  return
  }
  // check if already accumulated the specified number of logs

eth/tracers/native/4byte.go

@@ -46,7 +46,6 @@ func init() {
 // 0xc281d19e-0: 1
 // }
 type fourByteTracer struct {
- env *vm.EVM
  ids map[string]int // ids aggregates the 4byte ids found
  interrupt uint32 // Atomic flag to signal execution interruption
  reason error // Textual reason for the interruption
@@ -80,8 +79,6 @@ func (t *fourByteTracer) store(id []byte, size int) {
 
 // CaptureStart implements the EVMLogger interface to initialize the tracing operation.
 func (t *fourByteTracer) CaptureStart(env *vm.EVM, from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) {
- t.env = env
-
  // Update list of precompiles based on current block
  rules := env.ChainConfig().Rules(env.Context.BlockNumber, env.Context.Random != nil)
  t.activePrecompiles = vm.ActivePrecompiles(rules)
@@ -100,7 +97,6 @@ func (t *fourByteTracer) CaptureState(pc uint64, op vm.OpCode, gas, cost uint64,
 func (t *fourByteTracer) CaptureEnter(op vm.OpCode, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int) {
  // Skip if tracing was interrupted
  if atomic.LoadUint32(&t.interrupt) > 0 {
- t.env.Cancel()
  return
  }
  if len(input) < 4 {

eth/tracers/native/mux.go

@@ -0,0 +1,138 @@
+// Copyright 2022 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package native
+
+import (
+ "encoding/json"
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/ethereum/go-ethereum/eth/tracers"
+)
+
+func init() {
+ register("muxTracer", newMuxTracer)
+}
+
+// muxTracer is a go implementation of the Tracer interface which
+// runs multiple tracers in one go.
+type muxTracer struct {
+ names []string
+ tracers []tracers.Tracer
+}
+
+// newMuxTracer returns a new mux tracer.
+func newMuxTracer(ctx *tracers.Context, cfg json.RawMessage) (tracers.Tracer, error) {
+ var config map[string]json.RawMessage
+ if cfg != nil {
+ if err := json.Unmarshal(cfg, &config); err != nil {
+ return nil, err
+ }
+ }
+ objects := make([]tracers.Tracer, 0, len(config))
+ names := make([]string, 0, len(config))
+ for k, v := range config {
+ t, err := tracers.New(k, ctx, v)
+ if err != nil {
+ return nil, err
+ }
+ objects = append(objects, t)
+ names = append(names, k)
+ }
+
+ return &muxTracer{names: names, tracers: objects}, nil
+}
+
+// CaptureStart implements the EVMLogger interface to initialize the tracing operation.
+func (t *muxTracer) CaptureStart(env *vm.EVM, from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) {
+ for _, t := range t.tracers {
+ t.CaptureStart(env, from, to, create, input, gas, value)
+ }
+}
+
+// CaptureEnd is called after the call finishes to finalize the tracing.
+func (t *muxTracer) CaptureEnd(output []byte, gasUsed uint64, err error) {
+ for _, t := range t.tracers {
+ t.CaptureEnd(output, gasUsed, err)
+ }
+}
+
+// CaptureState implements the EVMLogger interface to trace a single step of VM execution.
+func (t *muxTracer) CaptureState(pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, rData []byte, depth int, err error) {
+ for _, t := range t.tracers {
+ t.CaptureState(pc, op, gas, cost, scope, rData, depth, err)
+ }
+}
+
+// CaptureFault implements the EVMLogger interface to trace an execution fault.
+func (t *muxTracer) CaptureFault(pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, depth int, err error) {
+ for _, t := range t.tracers {
+ t.CaptureFault(pc, op, gas, cost, scope, depth, err)
+ }
+}
+
+// CaptureEnter is called when EVM enters a new scope (via call, create or selfdestruct).
+func (t *muxTracer) CaptureEnter(typ vm.OpCode, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int) {
+ for _, t := range t.tracers {
+ t.CaptureEnter(typ, from, to, input, gas, value)
+ }
+}
+
+// CaptureExit is called when EVM exits a scope, even if the scope didn't
+// execute any code.
+func (t *muxTracer) CaptureExit(output []byte, gasUsed uint64, err error) {
+ for _, t := range t.tracers {
+ t.CaptureExit(output, gasUsed, err)
+ }
+}
+
+func (t *muxTracer) CaptureTxStart(gasLimit uint64) {
+ for _, t := range t.tracers {
+ t.CaptureTxStart(gasLimit)
+ }
+}
+
+func (t *muxTracer) CaptureTxEnd(restGas uint64) {
+ for _, t := range t.tracers {
+ t.CaptureTxEnd(restGas)
+ }
+}
+
+// GetResult returns an empty json object.
+func (t *muxTracer) GetResult() (json.RawMessage, error) {
+ resObject := make(map[string]json.RawMessage)
+ for i, tt := range t.tracers {
+ r, err := tt.GetResult()
+ if err != nil {
+ return nil, err
+ }
+ resObject[t.names[i]] = r
+ }
+ res, err := json.Marshal(resObject)
+ if err != nil {
+ return nil, err
+ }
+ return res, nil
+}
+
+// Stop terminates execution of the tracer at the first opportune moment.
+func (t *muxTracer) Stop(err error) {
+ for _, t := range t.tracers {
+ t.Stop(err)
+ }
+}