debug_traceBlockByNumber

Author: envestcc

action/protocol/execution/evm/context.go

@@ -3,19 +3,26 @@ package evm
 import (
 	"context"
 
+	"github.com/iotexproject/iotex-core/v2/action"
 	"github.com/iotexproject/iotex-core/v2/action/protocol"
 	"github.com/iotexproject/iotex-core/v2/pkg/log"
 )
 
 type (
 	helperContextKey struct{}
 
+	tracerContextKey struct{}
+
 	// HelperContext is the context for EVM helper
 	HelperContext struct {
 		GetBlockHash   GetBlockHash
 		GetBlockTime   GetBlockTime
 		DepositGasFunc protocol.DepositGas
 	}
+
+	TracerContext struct {
+		CaptureTx func([]byte, *action.Receipt)
+	}
 )
 
 // WithHelperCtx returns a new context with helper context
@@ -31,3 +38,12 @@ func mustGetHelperCtx(ctx context.Context) HelperContext {
 	}
 	return hc
 }
+
+func WithTracerCtx(ctx context.Context, tctx TracerContext) context.Context {
+	return context.WithValue(ctx, tracerContextKey{}, tctx)
+}
+
+func GetTracerCtx(ctx context.Context) (TracerContext, bool) {
+	tc, ok := ctx.Value(tracerContextKey{}).(TracerContext)
+	return tc, ok
+}

action/protocol/execution/evm/evm.go

@@ -332,6 +332,9 @@ func ExecuteContract(
 		receipt.SetExecutionRevertMsg(revertMsg)
 	}
 	log.S().Debugf("Receipt: %+v, %v", receipt, err)
+	if tCtx, ok := GetTracerCtx(ctx); ok && tCtx.CaptureTx != nil {
+		tCtx.CaptureTx(retval, receipt)
+	}
 	return retval, receipt, nil
 }
 

api/coreservice.go

@@ -190,6 +190,8 @@ type (
 		Track(ctx context.Context, start time.Time, method string, size int64, success bool)
 		// BlobSidecarsByHeight returns blob sidecars by height
 		BlobSidecarsByHeight(height uint64) ([]*apitypes.BlobSidecarResult, error)
+		// TraceBlockByNumber returns the trace result of a block by its height
+		TraceBlockByNumber(ctx context.Context, height uint64, config *tracers.TraceConfig) ([][]byte, []*action.Receipt, any, error)
 
 		// Historical methods
 		BalanceAt(ctx context.Context, addr address.Address, height uint64) (string, error)
@@ -2139,6 +2141,14 @@ func (core *coreService) TraceCall(ctx context.Context,
 	})
 }
 
+func (core *coreService) TraceBlockByNumber(ctx context.Context, height uint64, config *tracers.TraceConfig) ([][]byte, []*action.Receipt, any, error) {
+	blk, err := core.dao.GetBlockByHeight(height)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	return core.traceBlock(ctx, blk, config)
+}
+
 // Track tracks the api call
 func (core *coreService) Track(ctx context.Context, start time.Time, method string, size int64, success bool) {
 	if core.apiStats == nil {
@@ -2154,44 +2164,21 @@ func (core *coreService) Track(ctx context.Context, start time.Time, method stri
 }
 
 func (core *coreService) traceTx(ctx context.Context, txctx *tracers.Context, config *tracers.TraceConfig, simulateFn func(ctx context.Context) ([]byte, *action.Receipt, error)) ([]byte, *action.Receipt, any, error) {
-	var (
-		tracer vm.EVMLogger
-		err    error
-	)
-	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, nil, nil, err
-			}
-		}
-		t, err := tracers.DefaultDirectory.New(*config.Tracer, txctx, config.TracerConfig)
-		if err != nil {
-			return nil, nil, nil, err
-		}
-		deadlineCtx, cancel := context.WithTimeout(ctx, timeout)
-		defer cancel()
-		go func() {
-			<-deadlineCtx.Done()
-			if errors.Is(deadlineCtx.Err(), context.DeadlineExceeded) {
-				t.Stop(errors.New("execution timeout"))
-			}
-		}()
-		tracer = t
+	ctx, tracer, err := core.traceContext(ctx, txctx, config)
+	retval, receipt, err := simulateFn(ctx)
+	return retval, receipt, tracer, err
+}
 
-	default:
-		tracer = logger.NewStructLogger(config.Config)
+func (core *coreService) traceContext(ctx context.Context, txctx *tracers.Context, config *tracers.TraceConfig) (context.Context, *evmTracer, error) {
+	tracer := newEVMTracer(txctx, config)
+	if err := tracer.Reset(); err != nil {
+		return nil, nil, status.Error(codes.InvalidArgument, fmt.Sprintf("failed to reset tracer: %v", err))
 	}
 	ctx = protocol.WithVMConfigCtx(ctx, vm.Config{
 		Tracer:    tracer,
 		NoBaseFee: true,
 	})
-	retval, receipt, err := simulateFn(ctx)
-	return retval, receipt, tracer, err
+	return ctx, tracer, nil
 }
 
 func (core *coreService) simulateExecution(
@@ -2262,6 +2249,67 @@ func (core *coreService) getStateManager(ctx context.Context, height uint64) (co
 	return ctx, ws, err
 }
 
+func (core *coreService) traceBlock(ctx context.Context, blk *block.Block, config *tracers.TraceConfig) ([][]byte, []*action.Receipt, any, error) {
+	ctx, err := core.bc.ContextAtHeight(ctx, blk.Height())
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	g := core.bc.Genesis()
+	ctx = protocol.WithBlockCtx(ctx, protocol.BlockCtx{
+		BlockHeight:    blk.Height(),
+		BlockTimeStamp: blk.Timestamp(),
+		GasLimit:       g.BlockGasLimitByHeight(blk.Height()),
+		Producer:       blk.PublicKey().Address(),
+	})
+	ctx = protocol.WithRegistry(ctx, core.registry)
+	ctx = protocol.WithFeatureCtx(ctx)
+	retvals := make([][]byte, 0)
+	receipts := make([]*action.Receipt, 0)
+	results := make([]*blockTraceResult, 0)
+	ctx, tracer, err := core.traceContext(ctx, new(tracers.Context), config)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	ctx = evm.WithTracerCtx(ctx, evm.TracerContext{
+		CaptureTx: func(retval []byte, receipt *action.Receipt) {
+			defer tracer.Reset()
+			var res any
+			switch innerTracer := tracer.EVMLogger.(type) {
+			case *logger.StructLogger:
+				res = &debugTraceTransactionResult{
+					Failed:      receipt.Status != uint64(iotextypes.ReceiptStatus_Success),
+					Revert:      receipt.ExecutionRevertMsg(),
+					ReturnValue: byteToHex(retval),
+					StructLogs:  fromLoggerStructLogs(innerTracer.StructLogs()),
+					Gas:         receipt.GasConsumed,
+				}
+			case tracers.Tracer:
+				res, err = innerTracer.GetResult()
+				if err != nil {
+					log.L().Error("failed to get tracer result", zap.Error(err))
+					return
+				}
+			default:
+				log.L().Error("unknown tracer type", zap.Any("tracer", innerTracer))
+				return
+			}
+			results = append(results, &blockTraceResult{
+				TxHash: receipt.ActionHash,
+				Result: res,
+			})
+			retvals = append(retvals, retval)
+			receipts = append(receipts, receipt)
+		},
+	})
+	ws, err := core.sf.WorkingSetAtHeight(ctx, blk.Height()-1, blk.Actions...)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	defer ws.Close()
+
+	return retvals, receipts, results, nil
+}
+
 func filterReceipts(receipts []*action.Receipt, actHash hash.Hash256) *action.Receipt {
 	for _, r := range receipts {
 		if r.ActionHash == actHash {

api/coreservice_test.go

@@ -623,7 +623,7 @@ func TestTraceTransaction(t *testing.T) {
 	require.Equal(uint64(1), receipt.Status)
 	require.Equal(uint64(0x2710), receipt.GasConsumed)
 	require.Empty(receipt.ExecutionRevertMsg())
-	require.Equal(0, len(traces.(*logger.StructLogger).StructLogs()))
+	require.Equal(0, len(traces.(*evmTracer).EVMLogger.(*logger.StructLogger).StructLogs()))
 }
 
 func TestTraceCall(t *testing.T) {
@@ -661,7 +661,7 @@ func TestTraceCall(t *testing.T) {
 	require.Equal(uint64(1), receipt.Status)
 	require.Equal(uint64(0x2710), receipt.GasConsumed)
 	require.Empty(receipt.ExecutionRevertMsg())
-	require.Equal(0, len(traces.(*logger.StructLogger).StructLogs()))
+	require.Equal(0, len(traces.(*evmTracer).EVMLogger.(*logger.StructLogger).StructLogs()))
 }
 
 func TestProofAndCompareReverseActions(t *testing.T) {
@@ -1085,83 +1085,3 @@ func TestTrack(t *testing.T) {
 		cs.Track(nil, time.Now(), "", 0, true)
 	})
 }
-
-func TestTraceTx(t *testing.T) {
-	require := require.New(t)
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-
-	var (
-		bc = mock_blockchain.NewMockBlockchain(ctrl)
-		cs = &coreService{
-			bc: bc,
-		}
-		ctx = context.Background()
-	)
-
-	t.Run("ConfigIsNil", func(t *testing.T) {
-		p := NewPatches()
-		defer p.Reset()
-
-		p = p.ApplyFuncReturn(logger.NewStructLogger, nil)
-		p = p.ApplyFuncReturn(protocol.WithVMConfigCtx, ctx)
-		p = p.ApplyFuncReturn(protocol.WithBlockCtx, ctx)
-		p = p.ApplyFuncReturn(genesis.WithGenesisContext, ctx)
-		p = p.ApplyFuncReturn(protocol.WithBlockchainCtx, ctx)
-		p = p.ApplyFuncReturn(protocol.WithFeatureCtx, ctx)
-		retval, receipt, tracer, err := cs.traceTx(ctx, nil, nil, func(ctx context.Context) ([]byte, *action.Receipt, error) {
-			return nil, nil, nil
-		})
-		require.NoError(err)
-		require.Empty(retval)
-		require.Empty(receipt)
-		require.Empty(tracer)
-	})
-
-	t.Run("TracerIsNotNil", func(t *testing.T) {
-
-		t.Run("FailedToParseDuration", func(t *testing.T) {
-			p := NewPatches()
-			defer p.Reset()
-
-			p = p.ApplyFuncReturn(time.ParseDuration, nil, errors.New(t.Name()))
-
-			testStr := "TestTracer"
-			_, _, _, err := cs.traceTx(ctx, nil, &tracers.TraceConfig{Tracer: &testStr, Timeout: &testStr}, func(ctx context.Context) ([]byte, *action.Receipt, error) {
-				return nil, nil, nil
-			})
-			require.ErrorContains(err, t.Name())
-		})
-
-		t.Run("FailedToNewTracer", func(t *testing.T) {
-			p := NewPatches()
-			defer p.Reset()
-
-			p = p.ApplyMethodReturn(&tracers.DefaultDirectory, "New", nil, errors.New(t.Name()))
-			testStr := "TestTracer"
-			_, _, _, err := cs.traceTx(ctx, nil, &tracers.TraceConfig{Tracer: &testStr}, func(ctx context.Context) ([]byte, *action.Receipt, error) {
-				return nil, nil, nil
-			})
-			require.ErrorContains(err, t.Name())
-		})
-	})
-
-	t.Run("TracerIsNil", func(t *testing.T) {
-		p := NewPatches()
-		defer p.Reset()
-
-		p = p.ApplyFuncReturn(logger.NewStructLogger, nil)
-		p = p.ApplyFuncReturn(protocol.WithVMConfigCtx, ctx)
-		p = p.ApplyFuncReturn(protocol.WithBlockCtx, ctx)
-		p = p.ApplyFuncReturn(genesis.WithGenesisContext, ctx)
-		p = p.ApplyFuncReturn(protocol.WithBlockchainCtx, ctx)
-		p = p.ApplyFuncReturn(protocol.WithFeatureCtx, ctx)
-		retval, receipt, tracer, err := cs.traceTx(ctx, nil, &tracers.TraceConfig{}, func(ctx context.Context) ([]byte, *action.Receipt, error) {
-			return nil, nil, nil
-		})
-		require.NoError(err)
-		require.Empty(retval)
-		require.Empty(receipt)
-		require.Empty(tracer)
-	})
-}

api/grpcserver.go

@@ -696,7 +696,7 @@ func (svr *gRPCHandler) TraceTransactionStructLogs(ctx context.Context, in *iote
 	}
 	structLogs := make([]*iotextypes.TransactionStructLog, 0)
 	//grpc not support javascript tracing, so we only return native traces
-	traces := tracer.(*logger.StructLogger)
+	traces := tracer.(*evmTracer).EVMLogger.(*logger.StructLogger)
 	for _, log := range traces.StructLogs() {
 		var stack []string
 		for _, s := range log.Stack {

api/grpcserver_test.go

@@ -1025,7 +1025,7 @@ func TestGrpcServer_TraceTransactionStructLogs(t *testing.T) {
 	core := NewMockCoreService(ctrl)
 	grpcSvr := newGRPCHandler(core)
 
-	core.EXPECT().TraceTransaction(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, nil, logger.NewStructLogger(nil), nil)
+	core.EXPECT().TraceTransaction(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, nil, &evmTracer{EVMLogger: logger.NewStructLogger(nil)}, nil)
 	resp, err := grpcSvr.TraceTransactionStructLogs(context.Background(), &iotexapi.TraceTransactionStructLogsRequest{
 		ActionHash: "_actionHash",
 	})

api/mock_apicoreservice.go

@@ -254,11 +254,12 @@ func (svr *web3Handler) handleWeb3Req(ctx context.Context, web3Req *gjson.Result
 		res, err = svr.unsubscribe(web3Req)
 	case "eth_getBlobSidecars":
 		res, err = svr.getBlobSidecars(web3Req)
-	//TODO: enable debug api after archive mode is supported
 	case "debug_traceTransaction":
 		res, err = svr.traceTransaction(ctx, web3Req)
 	case "debug_traceCall":
 		res, err = svr.traceCall(ctx, web3Req)
+	case "debug_traceBlockByNumber":
+		res, err = svr.traceBlockByNumber(ctx, web3Req)
 	case "eth_coinbase", "eth_getUncleCountByBlockHash", "eth_getUncleCountByBlockNumber",
 		"eth_sign", "eth_signTransaction", "eth_sendTransaction", "eth_getUncleByBlockHashAndIndex",
 		"eth_getUncleByBlockNumberAndIndex", "eth_pendingTransactions":
@@ -1171,6 +1172,18 @@ func (svr *web3Handler) traceCall(ctx context.Context, in *gjson.Result) (interf
 	}
 }
 
+func (svr *web3Handler) traceBlockByNumber(ctx context.Context, in *gjson.Result) (any, error) {
+	blkParam, tracerParam := in.Get("params.0"), in.Get("params.1")
+	blkNum, err := parseBlockNumber(&blkParam)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to parse block number")
+	}
+	height, _ := blockNumberToHeight(blkNum)
+	tracer := parseTracerConfig(&tracerParam)
+	_, _, results, err := svr.coreService.TraceBlockByNumber(ctx, height, tracer)
+	return results, err
+}
+
 func (svr *web3Handler) unimplemented() (interface{}, error) {
 	return nil, errNotImplemented
 }

api/web3server.go

@@ -88,6 +88,11 @@ type (
 		StructLogs  []apitypes.StructLog `json:"structLogs"`
 	}
 
+	blockTraceResult struct {
+		TxHash hash.Hash256 `json:"txHash"`
+		Result any          `json:"result"`
+	}
+
 	feeHistoryResult struct {
 		OldestBlock       string     `json:"oldestBlock"`
 		BaseFeePerGas     []string   `json:"baseFeePerGas"`
@@ -455,3 +460,13 @@ func (obj *streamResponse) MarshalJSON() ([]byte, error) {
 		},
 	})
 }
+
+func (obj *blockTraceResult) MarshalJSON() ([]byte, error) {
+	return json.Marshal(&struct {
+		TxHash string `json:"txHash"`
+		Result any    `json:"result"`
+	}{
+		TxHash: "0x" + hex.EncodeToString(obj.TxHash[:]),
+		Result: obj.Result,
+	})
+}