Merge pull request #490 from iotaledger/merge-evmtrace

Merge wasp/develop

Author: dessaya

packages/chainutil/evmcall.go

@@ -51,6 +51,7 @@ func EVMCall(
 		log,
 		time.Now(),
 		iscReq,
+		true,
 	)
 	if err != nil {
 		return nil, err

packages/chainutil/evmestimategas.go

@@ -76,6 +76,7 @@ func EVMEstimateGas(
 			log,
 			blockTime,
 			iscReq,
+			true,
 		)
 		if err != nil {
 			return true, nil, err

packages/chainutil/evmtrace.go

@@ -12,16 +12,14 @@ import (
 	"github.com/iotaledger/wasp/packages/vm/processors"
 )
 
-func EVMTraceTransaction(
+func EVMTrace(
 	anchor *isc.StateAnchor,
 	l1Params *parameters.L1Params,
 	store indexedstore.IndexedStore,
 	processors *processors.Config,
 	log *logger.Logger,
 	blockTime time.Time,
 	iscRequestsInBlock []isc.Request,
-	txIndex *uint64,
-	blockNumber *uint64,
 	tracer *tracers.Tracer,
 ) error {
 	_, err := runISCTask(
@@ -32,11 +30,8 @@ func EVMTraceTransaction(
 		log,
 		blockTime,
 		iscRequestsInBlock,
-		&isc.EVMTracer{
-			Tracer:      tracer,
-			TxIndex:     txIndex,
-			BlockNumber: blockNumber,
-		},
+		false,
+		tracer,
 	)
 	return err
 }

packages/chainutil/runvm.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"time"
 
+	"github.com/ethereum/go-ethereum/eth/tracers"
 	"github.com/samber/lo"
 	"go.uber.org/zap"
 
@@ -30,16 +31,13 @@ func runISCTask(
 	log *logger.Logger,
 	blockTime time.Time,
 	reqs []isc.Request,
-	evmTracer *isc.EVMTracer,
+	estimateGasMode bool,
+	evmTracer *tracers.Tracer,
 ) ([]*vm.RequestResult, error) {
 	migs, err := getMigrationsForBlock(store, anchor)
 	if err != nil {
 		return nil, err
 	}
-	estimateGasMode := true
-	if evmTracer != nil {
-		estimateGasMode = false
-	}
 	task := &vm.VMTask{
 		Processors:           processors,
 		Anchor:               anchor,
@@ -91,6 +89,7 @@ func runISCRequest(
 	log *logger.Logger,
 	blockTime time.Time,
 	req isc.Request,
+	estimateGasMode bool,
 ) (*vm.RequestResult, error) {
 	results, err := runISCTask(
 		anchor,
@@ -100,6 +99,7 @@ func runISCRequest(
 		log,
 		blockTime,
 		[]isc.Request{req},
+		estimateGasMode,
 		nil,
 	)
 	if err != nil {

packages/chainutil/simulate_request.go

@@ -18,6 +18,7 @@ func SimulateRequest(
 	processors *processors.Config,
 	log *logger.Logger,
 	req isc.Request,
+	estimateGasMode bool,
 ) (*blocklog.RequestReceipt, error) {
 	res, err := runISCRequest(
 		anchor,
@@ -27,6 +28,7 @@ func SimulateRequest(
 		log,
 		time.Now(),
 		req,
+		estimateGasMode,
 	)
 	if err != nil {
 		return nil, err

packages/evm/jsonrpc/chainbackend.go

@@ -22,12 +22,10 @@ type ChainBackend interface {
 	EVMSendTransaction(tx *types.Transaction) error
 	EVMCall(anchor *isc.StateAnchor, callMsg ethereum.CallMsg, l1Params *parameters.L1Params) ([]byte, error)
 	EVMEstimateGas(anchor *isc.StateAnchor, callMsg ethereum.CallMsg, l1Params *parameters.L1Params) (uint64, error)
-	EVMTraceTransaction(
+	EVMTrace(
 		anchor *isc.StateAnchor,
 		blockTime time.Time,
 		iscRequestsInBlock []isc.Request,
-		txIndex *uint64,
-		blockNumber *uint64,
 		tracer *tracers.Tracer,
 		l1Params *parameters.L1Params,
 	) error

packages/evm/jsonrpc/evmchain.go

@@ -672,36 +672,46 @@ func (e *EVMChain) traceTransaction(
 		tracerType = *config.Tracer
 	}
 
-	blockNumber := uint64(blockInfo.BlockIndex)
-
-	tracer, err := newTracer(tracerType, &tracers.Context{
-		BlockHash:   blockHash,
-		BlockNumber: new(big.Int).SetUint64(blockNumber),
-		TxIndex:     int(txIndex),
-		TxHash:      tx.Hash(),
-	}, config.TracerConfig, false, nil)
+	tracer, err := newTracer(
+		tracerType,
+		&tracers.Context{
+			BlockHash:   blockHash,
+			BlockNumber: new(big.Int).SetUint64(uint64(blockInfo.BlockIndex)),
+			TxIndex:     int(txIndex),
+			TxHash:      tx.Hash(),
+		},
+		config.TracerConfig,
+	)
 	if err != nil {
 		return nil, err
 	}
 
-	if evmutil.IsFakeTransaction(tx) {
-		return tracer.TraceFakeTx(tx)
-	}
-
-	err = e.backend.EVMTraceTransaction(
+	err = e.backend.EVMTrace(
 		blockInfo.PreviousAnchor,
 		blockInfo.Timestamp,
 		requestsInBlock,
-		&txIndex,
-		&blockNumber,
-		tracer.Tracer,
+		tracer,
 		blockInfo.L1Params,
 	)
 	if err != nil {
 		return nil, err
 	}
 
-	return tracer.GetResult()
+	res, err := tracer.GetResult()
+	if err != nil {
+		return nil, err
+	}
+
+	var txResults []TxTraceResult
+	err = json.Unmarshal(res, &txResults)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(txResults) <= int(txIndex) {
+		return nil, errors.New("tx trace not found in tracer result")
+	}
+	return txResults[int(txIndex)].Result, nil
 }
 
 func (e *EVMChain) debugTraceBlock(config *tracers.TraceConfig, block *types.Block) (any, error) {
@@ -715,31 +725,28 @@ func (e *EVMChain) debugTraceBlock(config *tracers.TraceConfig, block *types.Blo
 		tracerType = *config.Tracer
 	}
 
-	blockNumber := uint64(iscBlock.BlockIndex)
-
-	blockTxs := block.Transactions()
-
-	tracer, err := newTracer(tracerType, &tracers.Context{
-		BlockHash:   block.Hash(),
-		BlockNumber: new(big.Int).SetUint64(blockNumber),
-	}, config.TracerConfig, true, blockTxs)
+	tracer, err := newTracer(
+		tracerType,
+		&tracers.Context{
+			BlockHash:   block.Hash(),
+			BlockNumber: new(big.Int).SetUint64(uint64(iscBlock.BlockIndex)),
+		},
+		config.TracerConfig,
+	)
 	if err != nil {
 		return nil, err
 	}
 
-	err = e.backend.EVMTraceTransaction(
+	err = e.backend.EVMTrace(
 		iscBlock.PreviousAnchor,
 		iscBlock.Timestamp,
 		iscRequestsInBlock,
-		nil,
-		&blockNumber,
-		tracer.Tracer,
+		tracer,
 		iscBlock.L1Params,
 	)
 	if err != nil {
 		return nil, err
 	}
-
 	return tracer.GetResult()
 }
 

packages/evm/jsonrpc/jsonrpctest/jsonrpc_test.go

@@ -611,15 +611,15 @@ func TestRPCTraceTx(t *testing.T) {
 
 	t.Run("prestate", func(t *testing.T) {
 		accountMap, err := env.traceTransactionWithPrestate(tx1.Hash())
+		// t.Logf("%s", lo.Must(json.MarshalIndent(accountMap, "", "  ")))
 		require.NoError(t, err)
 		require.NotEmpty(t, accountMap)
-		// t.Logf("%s", lo.Must(json.MarshalIndent(accountMap, "", "  ")))
 
 		diff, err := env.traceTransactionWithPrestateDiff(tx1.Hash())
+		// t.Logf("%s", lo.Must(json.MarshalIndent(diff, "", "  ")))
 		require.NoError(t, err)
 		require.NotEmpty(t, diff.Pre)
 		require.NotEmpty(t, diff.Post)
-		// t.Logf("%s", lo.Must(json.MarshalIndent(diff, "", "  ")))
 	})
 }
 

packages/evm/jsonrpc/tracer.go

@@ -4,72 +4,32 @@ import (
 	"encoding/json"
 	"fmt"
 
-	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/eth/tracers"
-
-	"github.com/iotaledger/wasp/packages/evm/evmutil"
 )
 
-type Tracer struct {
-	*tracers.Tracer
-	TraceFakeTx func(tx *types.Transaction) (json.RawMessage, error)
-}
-
-type tracerFactory func(traceCtx *tracers.Context, cfg json.RawMessage, traceBlock bool, initValue any) (*Tracer, error)
+type tracerFactory func(traceCtx *tracers.Context, cfg json.RawMessage) (*tracers.Tracer, error)
 
 var allTracers = map[string]tracerFactory{}
 
 func registerTracer(tracerType string, fn tracerFactory) {
 	allTracers[tracerType] = fn
 }
 
-func newTracer(tracerType string, ctx *tracers.Context, cfg json.RawMessage, traceBlock bool, initValue any) (*Tracer, error) {
+func newTracer(
+	tracerType string,
+	ctx *tracers.Context,
+	cfg json.RawMessage,
+) (*tracers.Tracer, error) {
 	fn := allTracers[tracerType]
 	if fn == nil {
 		return nil, fmt.Errorf("unsupported tracer type: %s", tracerType)
 	}
-	return fn(ctx, cfg, traceBlock, initValue)
+	return fn(ctx, cfg)
 }
 
-func GetTraceResults(
-	blockTxs []*types.Transaction,
-	traceBlock bool,
-	getFakeTxTrace func(tx *types.Transaction) (json.RawMessage, error),
-	getTxTrace func(tx *types.Transaction) (json.RawMessage, error),
-	getSingleTxTrace func() (json.RawMessage, error),
-	reason error,
-) (json.RawMessage, error) {
-	var traceResult []byte
-	var err error
-	if traceBlock {
-		results := make([]TxTraceResult, 0, len(blockTxs))
-		var jsResult json.RawMessage
-		for _, tx := range blockTxs {
-			if evmutil.IsFakeTransaction(tx) {
-				jsResult, err = getFakeTxTrace(tx)
-				if err != nil {
-					return nil, err
-				}
-			} else {
-				jsResult, err = getTxTrace(tx)
-				if err != nil {
-					return nil, err
-				}
-			}
-
-			results = append(results, TxTraceResult{TxHash: tx.Hash(), Result: jsResult})
-		}
-
-		traceResult, err = json.Marshal(results)
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		traceResult, err = getSingleTxTrace()
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return traceResult, reason
+type TxTraceResult struct {
+	TxHash common.Hash     `json:"txHash"`           // transaction hash
+	Result json.RawMessage `json:"result,omitempty"` // Trace results produced by the tracer
+	Error  string          `json:"error,omitempty"`  // Trace failure produced by the tracer
 }