cmd/evm: t8n support native tracers

cmd/evm/internal/t8ntool/execution.go

@@ -117,7 +117,7 @@ type rejectedTx struct {
 // Apply applies a set of transactions to a pre-state
 func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 	txIt txIterator, miningReward int64,
-	getTracerFn func(txIndex int, txHash common.Hash) (tracer vm.EVMLogger, err error)) (*state.StateDB, *ExecutionResult, []byte, error) {
+	getTracerFn func(txIndex int, txHash common.Hash) (vm.EVMLogger, error)) (*state.StateDB, *ExecutionResult, []byte, error) {
 	// Capture errors for BLOCKHASH operation, if we haven't been supplied the
 	// required blockhashes
 	var hashError error

cmd/evm/internal/t8ntool/flags.go

@@ -30,10 +30,13 @@ var (
 		Name:  "trace",
 		Usage: "Output full trace logs to files <txhash>.jsonl",
 	}
-	TraceDisableMemoryFlag = &cli.BoolFlag{
-		Name:  "trace.nomemory",
-		Value: true,
-		Usage: "Disable full memory dump in traces (deprecated)",
+	TraceTracerFlag = &cli.StringFlag{
+		Name:  "trace.tracer",
+		Usage: "The type of tracer. It could be callTracer or prestateTracer",
+	}
+	TraceTracerConfigFlag = &cli.StringFlag{
+		Name:  "trace.tracer.config",
+		Usage: "The configurations of --trace.tracer, in JSON encoded format",
 	}
 	TraceEnableMemoryFlag = &cli.BoolFlag{
 		Name:  "trace.memory",
@@ -43,11 +46,6 @@ var (
 		Name:  "trace.nostack",
 		Usage: "Disable stack output in traces",
 	}
-	TraceDisableReturnDataFlag = &cli.BoolFlag{
-		Name:  "trace.noreturndata",
-		Value: true,
-		Usage: "Disable return data output in traces (deprecated)",
-	}
 	TraceEnableReturnDataFlag = &cli.BoolFlag{
 		Name:  "trace.returndata",
 		Usage: "Enable return data output in traces",

cmd/evm/internal/t8ntool/tracewriter.go

@@ -0,0 +1,81 @@
+// Copyright 2020 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+package t8ntool
+
+import (
+	"encoding/json"
+	"io"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/eth/tracers"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+// traceWriter is an vm.EVMLogger which also holds an inner logger/tracer.
+// When the TxEnd event happens, the inner tracer result is written to the file, and
+// the file is closed.
+type traceWriter struct {
+	inner vm.EVMLogger
+	f     io.WriteCloser
+}
+
+// Compile-time interface check
+var _ = vm.EVMLogger((*traceWriter)(nil))
+
+func (t *traceWriter) CaptureTxEnd(restGas uint64) {
+	t.inner.CaptureTxEnd(restGas)
+	defer t.f.Close()
+
+	if tracer, ok := t.inner.(tracers.Tracer); ok {
+		result, err := tracer.GetResult()
+		if err != nil {
+			log.Warn("Error in tracer", "err", err)
+			return
+		}
+		err = json.NewEncoder(t.f).Encode(result)
+		if err != nil {
+			log.Warn("Error writing tracer output", "err", err)
+			return
+		}
+	}
+}
+
+func (t *traceWriter) CaptureTxStart(gasLimit uint64) { t.inner.CaptureTxStart(gasLimit) }
+func (t *traceWriter) CaptureStart(env *vm.EVM, from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) {
+	t.inner.CaptureStart(env, from, to, create, input, gas, value)
+}
+
+func (t *traceWriter) CaptureEnd(output []byte, gasUsed uint64, err error) {
+	t.inner.CaptureEnd(output, gasUsed, err)
+}
+
+func (t *traceWriter) CaptureEnter(typ vm.OpCode, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int) {
+	t.inner.CaptureEnter(typ, from, to, input, gas, value)
+}
+
+func (t *traceWriter) CaptureExit(output []byte, gasUsed uint64, err error) {
+	t.inner.CaptureExit(output, gasUsed, err)
+}
+
+func (t *traceWriter) CaptureState(pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, rData []byte, depth int, err error) {
+	t.inner.CaptureState(pc, op, gas, cost, scope, rData, depth, err)
+}
+func (t *traceWriter) CaptureFault(pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, depth int, err error) {
+	t.inner.CaptureFault(pc, op, gas, cost, scope, depth, err)
+}

cmd/evm/internal/t8ntool/transition.go

@@ -31,6 +31,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/eth/tracers"
 	"github.com/ethereum/go-ethereum/eth/tracers/logger"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
@@ -85,57 +86,45 @@ func Transition(ctx *cli.Context) error {
 	glogger.Verbosity(log.Lvl(ctx.Int(VerbosityFlag.Name)))
 	log.Root().SetHandler(glogger)
 
-	var (
-		err    error
-		tracer vm.EVMLogger
-	)
-	var getTracer func(txIndex int, txHash common.Hash) (vm.EVMLogger, error)
+	var getTracer = func(txIndex int, txHash common.Hash) (vm.EVMLogger, error) { return nil, nil }
 
 	baseDir, err := createBasedir(ctx)
 	if err != nil {
 		return NewError(ErrorIO, fmt.Errorf("failed creating output basedir: %v", err))
 	}
+
 	if ctx.Bool(TraceFlag.Name) {
-		if ctx.IsSet(TraceDisableMemoryFlag.Name) && ctx.IsSet(TraceEnableMemoryFlag.Name) {
-			return NewError(ErrorConfig, fmt.Errorf("can't use both flags --%s and --%s", TraceDisableMemoryFlag.Name, TraceEnableMemoryFlag.Name))
-		}
-		if ctx.IsSet(TraceDisableReturnDataFlag.Name) && ctx.IsSet(TraceEnableReturnDataFlag.Name) {
-			return NewError(ErrorConfig, fmt.Errorf("can't use both flags --%s and --%s", TraceDisableReturnDataFlag.Name, TraceEnableReturnDataFlag.Name))
-		}
-		if ctx.IsSet(TraceDisableMemoryFlag.Name) {
-			log.Warn(fmt.Sprintf("--%s has been deprecated in favour of --%s", TraceDisableMemoryFlag.Name, TraceEnableMemoryFlag.Name))
-		}
-		if ctx.IsSet(TraceDisableReturnDataFlag.Name) {
-			log.Warn(fmt.Sprintf("--%s has been deprecated in favour of --%s", TraceDisableReturnDataFlag.Name, TraceEnableReturnDataFlag.Name))
-		}
-		// Configure the EVM logger
-		logConfig := &logger.Config{
-			DisableStack:     ctx.Bool(TraceDisableStackFlag.Name),
-			EnableMemory:     !ctx.Bool(TraceDisableMemoryFlag.Name) || ctx.Bool(TraceEnableMemoryFlag.Name),
-			EnableReturnData: !ctx.Bool(TraceDisableReturnDataFlag.Name) || ctx.Bool(TraceEnableReturnDataFlag.Name),
-			Debug:            true,
-		}
-		var prevFile *os.File
-		// This one closes the last file
-		defer func() {
-			if prevFile != nil {
-				prevFile.Close()
+		if ctx.IsSet(TraceTracerFlag.Name) {
+			var config json.RawMessage
+			if ctx.IsSet(TraceTracerConfigFlag.Name) {
+				config = []byte(ctx.String(TraceTracerConfigFlag.Name))
 			}
-		}()
-		getTracer = func(txIndex int, txHash common.Hash) (vm.EVMLogger, error) {
-			if prevFile != nil {
-				prevFile.Close()
+			getTracer = func(txIndex int, txHash common.Hash) (vm.EVMLogger, error) {
+				traceFile, err := os.Create(path.Join(baseDir, fmt.Sprintf("trace-%d-%v.json", txIndex, txHash.String())))
+				if err != nil {
+					return nil, NewError(ErrorIO, fmt.Errorf("failed creating trace-file: %v", err))
+				}
+				tracer, err := tracers.DefaultDirectory.New(ctx.String(TraceTracerFlag.Name), nil, config)
+				if err != nil {
+					return nil, NewError(ErrorConfig, fmt.Errorf("failed instantiating tracer: %w", err))
+				}
+				return &traceWriter{tracer, traceFile}, nil
 			}
-			traceFile, err := os.Create(path.Join(baseDir, fmt.Sprintf("trace-%d-%v.jsonl", txIndex, txHash.String())))
-			if err != nil {
-				return nil, NewError(ErrorIO, fmt.Errorf("failed creating trace-file: %v", err))
+		} else {
+			// Configure the EVM logger
+			logConfig := &logger.Config{
+				DisableStack:     ctx.Bool(TraceDisableStackFlag.Name),
+				EnableMemory:     ctx.Bool(TraceEnableMemoryFlag.Name),
+				EnableReturnData: ctx.Bool(TraceEnableReturnDataFlag.Name),
+				Debug:            true,
+			}
+			getTracer = func(txIndex int, txHash common.Hash) (vm.EVMLogger, error) {
+				traceFile, err := os.Create(path.Join(baseDir, fmt.Sprintf("trace-%d-%v.jsonl", txIndex, txHash.String())))
+				if err != nil {
+					return nil, NewError(ErrorIO, fmt.Errorf("failed creating trace-file: %v", err))
+				}
+				return &traceWriter{logger.NewJSONLogger(logConfig, traceFile), traceFile}, nil
 			}
-			prevFile = traceFile
-			return logger.NewJSONLogger(logConfig, traceFile), nil
-		}
-	} else {
-		getTracer = func(txIndex int, txHash common.Hash) (tracer vm.EVMLogger, err error) {
-			return nil, nil
 		}
 	}
 	// We need to load three things: alloc, env and transactions. May be either in
@@ -174,9 +163,7 @@ func Transition(ctx *cli.Context) error {
 	}
 	prestate.Env = *inputData.Env
 
-	vmConfig := vm.Config{
-		Tracer: tracer,
-	}
+	vmConfig := vm.Config{}
 	// Construct the chainconfig
 	var chainConfig *params.ChainConfig
 	if cConf, extraEips, err := tests.GetChainConfig(ctx.String(ForknameFlag.Name)); err != nil {

cmd/evm/main.go

@@ -26,6 +26,10 @@ import (
 	"github.com/ethereum/go-ethereum/internal/debug"
 	"github.com/ethereum/go-ethereum/internal/flags"
 	"github.com/urfave/cli/v2"
+
+	// Force-load the tracer engines to trigger registration
+	_ "github.com/ethereum/go-ethereum/eth/tracers/js"
+	_ "github.com/ethereum/go-ethereum/eth/tracers/native"
 )
 
 var (
@@ -143,10 +147,10 @@ var stateTransitionCommand = &cli.Command{
 	Action:  t8ntool.Transition,
 	Flags: []cli.Flag{
 		t8ntool.TraceFlag,
-		t8ntool.TraceDisableMemoryFlag,
+		t8ntool.TraceTracerFlag,
+		t8ntool.TraceTracerConfigFlag,
 		t8ntool.TraceEnableMemoryFlag,
 		t8ntool.TraceDisableStackFlag,
-		t8ntool.TraceDisableReturnDataFlag,
 		t8ntool.TraceEnableReturnDataFlag,
 		t8ntool.OutputBasedir,
 		t8ntool.OutputAllocFlag,