fix tracer after rebase.

eth/tracers/api.go

@@ -1321,33 +1321,32 @@ func (api *API) traceTx(ctx context.Context, message *core.Message, txctx *Conte
 		timeout   = defaultTraceTimeout
 		txContext = core.NewEVMTxContext(message)
 	)
-
-	if config == nil {
-		config = &TraceConfig{}
-	}
-	// Default tracer is the struct logger
-	tracer = logger.NewStructLogger(config.Config)
-	if config.Tracer != nil {
-		tracer, err = DefaultDirectory.New(*config.Tracer, txctx, config.TracerConfig)
-		if err != nil {
-			return nil, err
-		}
-		if *config.Tracer == "goCallTracer" {
-			tracer = NewCallTracer(statedb)
-		} else {
-			// Constuct the JavaScript tracer to execute with
-			if tracer, err = New(*config.Tracer, txctx); err != nil {
+	switch {
+	case config == nil:
+		tracer = logger.NewStructLogger(nil)
+	case config.Tracer != nil:
+		// Define a meaningful timeout of a single transaction trace
+		timeout := defaultTraceTimeout
+		if config.Timeout != nil {
+			if timeout, err = time.ParseDuration(*config.Timeout); err != nil {
 				return nil, err
 			}
-			// Handle timeouts and RPC cancellations
+		}
+		if t, err := DefaultDirectory.New(*config.Tracer, txctx, nil); err != nil {
+			return nil, err
+		} else {
 			deadlineCtx, cancel := context.WithTimeout(ctx, timeout)
 			go func() {
 				<-deadlineCtx.Done()
 				if errors.Is(deadlineCtx.Err(), context.DeadlineExceeded) {
-					tracer.(Tracer).Stop(errors.New("execution timeout"))
+					t.Stop(errors.New("execution timeout"))
 				}
 			}()
 			defer cancel()
+			tracer = t
+		}
+	default:
+		tracer = logger.NewStructLogger(config.Config)
 	}
 
 	vmenv := vm.NewEVM(vmctx, txContext, statedb, api.backend.ChainConfig(), vm.Config{Tracer: tracer, NoBaseFee: true})
@@ -1376,19 +1375,23 @@ func (api *API) traceTx(ctx context.Context, message *core.Message, txctx *Conte
 	// Call Prepare to clear out the statedb access list
 	statedb.SetTxContext(txctx.TxHash, txctx.TxIndex)
 
+	var result *core.ExecutionResult
+
 	if config.BorTx == nil {
 		config.BorTx = newBoolPtr(false)
 	}
 
 	if *config.BorTx {
 		callmsg := prepareCallMessage(*message)
 		// nolint : contextcheck
-		if _, err := statefull.ApplyBorMessage(*vmenv, callmsg); err != nil {
+		result, err = statefull.ApplyBorMessage(*vmenv, callmsg)
+		if err != nil {
 			return nil, fmt.Errorf("tracing failed: %w", err)
 		}
 	} else {
 		// nolint : contextcheck
-		if _, err = core.ApplyMessage(vmenv, message, new(core.GasPool).AddGas(message.GasLimit), context.Background()); err != nil {
+		result, err = core.ApplyMessage(vmenv, message, new(core.GasPool).AddGas(message.GasLimit), context.Background())
+		if err != nil {
 			return nil, fmt.Errorf("tracing failed: %w", err)
 		}
 	}

eth/tracers/call_tracer.go

@@ -1,7 +1,7 @@
 package tracers
 
 import (
-	"fmt"
+	"encoding/json"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -37,7 +37,8 @@ type call struct {
 
 type TracerResult interface {
 	vm.EVMLogger
-	GetResult() (interface{}, error)
+	GetResult() (json.RawMessage, error)
+	Stop(error)
 }
 
 type CallTracer struct {
@@ -46,6 +47,14 @@ type CallTracer struct {
 	statedb   *state.StateDB
 }
 
+func (tracer *CallTracer) CaptureTxStart(gasLimit uint64) {
+
+}
+
+func (tracer *CallTracer) CaptureTxEnd(restGas uint64) {
+
+}
+
 func NewCallTracer(statedb *state.StateDB) TracerResult {
 	return &CallTracer{
 		callStack: []*call{},
@@ -58,8 +67,11 @@ func (tracer *CallTracer) i() int {
 	return len(tracer.callStack) - 1
 }
 
-func (tracer *CallTracer) GetResult() (interface{}, error) {
-	return tracer.callStack[0], nil
+func (tracer *CallTracer) GetResult() (json.RawMessage, error) {
+	return json.Marshal(tracer.callStack[0])
+}
+
+func (tracer *CallTracer) Stop(_ error) {
 }
 
 func (tracer *CallTracer) CaptureStart(evm *vm.EVM, from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) {
@@ -73,9 +85,8 @@ func (tracer *CallTracer) CaptureStart(evm *vm.EVM, from common.Address, to comm
 		Calls: []*call{},
 	}}
 }
-func (tracer *CallTracer) CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) {
+func (tracer *CallTracer) CaptureEnd(output []byte, gasUsed uint64, err error) {
 	tracer.callStack[tracer.i()].GasUsed = hexutil.Uint64(gasUsed)
-	tracer.callStack[tracer.i()].Time = fmt.Sprintf("%v", t)
 	tracer.callStack[tracer.i()].Output = hexutil.Bytes(output)
 }