Merge pull request #939 from onflow/mpeter/remove-tx-trace-generation

Remove tx trace generation & storage from ingestion engine

Author: m-Peter

api/debug.go

@@ -2,9 +2,7 @@ package api
 
 import (
 	"context"
-	"errors"
 	"fmt"
-	"strings"
 
 	gethCommon "github.com/ethereum/go-ethereum/common"
 	gethTypes "github.com/ethereum/go-ethereum/core/types"
@@ -21,9 +19,7 @@ import (
 	"github.com/onflow/flow-evm-gateway/config"
 	ethTypes "github.com/onflow/flow-evm-gateway/eth/types"
 	"github.com/onflow/flow-evm-gateway/models"
-	errs "github.com/onflow/flow-evm-gateway/models/errors"
 	"github.com/onflow/flow-evm-gateway/services/evm"
-	"github.com/onflow/flow-evm-gateway/services/replayer"
 	"github.com/onflow/flow-evm-gateway/services/requester"
 	"github.com/onflow/flow-evm-gateway/storage"
 	"github.com/onflow/flow-evm-gateway/storage/pebble"
@@ -279,28 +275,6 @@ func (d *DebugAPI) traceTransaction(
 	hash gethCommon.Hash,
 	config *tracers.TraceConfig,
 ) (json.RawMessage, error) {
-	// If the given trace config is equal to the default call tracer used
-	// in block replay during ingestion, then we fetch the trace result
-	// from the Traces DB.
-	if isDefaultCallTracer(config) {
-		trace, err := d.tracer.GetTransaction(hash)
-		// If there is no error, we return the trace result from the DB.
-		if err == nil {
-			return trace, nil
-		}
-
-		// If we got an error of `ErrEntityNotFound`, for whatever reason,
-		// we simply re-compute the trace below. If we got any other error,
-		// we return it.
-		if !errors.Is(err, errs.ErrEntityNotFound) {
-			d.logger.Error().Err(err).Msgf(
-				"failed to retrieve default call trace for tx: %s",
-				hash,
-			)
-			return nil, err
-		}
-	}
-
 	receipt, err := d.receipts.GetByTransactionID(hash)
 	if err != nil {
 		return nil, err
@@ -371,23 +345,6 @@ func (d *DebugAPI) traceBlockByNumber(
 
 	results := make([]*txTraceResult, len(block.TransactionHashes))
 
-	// If the given trace config is equal to the default call tracer used
-	// in block replay during ingestion, then we fetch the trace result
-	// from the Traces DB.
-	if isDefaultCallTracer(config) {
-		for i, hash := range block.TransactionHashes {
-			trace, err := d.traceTransaction(hash, config)
-
-			if err != nil {
-				results[i] = &txTraceResult{TxHash: hash, Error: err.Error()}
-			} else {
-				results[i] = &txTraceResult{TxHash: hash, Result: trace}
-			}
-		}
-
-		return results, nil
-	}
-
 	blockExecutor, err := d.executorAtBlock(block)
 	if err != nil {
 		return nil, err
@@ -480,19 +437,3 @@ func (d *DebugAPI) tracerForReceipt(
 		d.evmChainConfig,
 	)
 }
-
-func isDefaultCallTracer(config *tracers.TraceConfig) bool {
-	if config == nil {
-		return false
-	}
-
-	if config.Tracer == nil || *config.Tracer != replayer.TracerName {
-		return false
-	}
-
-	// The default tracer config is `{"onlyTopCall":true}`, if the user adds
-	// any whitespace, e.g `{ "onlyTopCall": true }`, the comparison will fail.
-	// That's why we need to trim out all whitespace characters.
-	trimmedConfig := strings.ReplaceAll(string(config.TracerConfig), " ", "")
-	return trimmedConfig == replayer.TracerConfig
-}

bootstrap/bootstrap.go

@@ -168,23 +168,14 @@ func (b *Bootstrap) StartEventIngestion(ctx context.Context) error {
 		nextCadenceHeight,
 	)
 
-	callTracerCollector, err := replayer.NewCallTracerCollector(
-		b.config.EVMNetworkID,
-		b.logger,
-	)
-	if err != nil {
-		return err
-	}
 	blocksProvider := replayer.NewBlocksProvider(
 		b.storages.Blocks,
 		chainID,
-		callTracerCollector.TxTracer(),
 	)
 	replayerConfig := replayer.Config{
-		ChainID:             chainID,
-		RootAddr:            evm.StorageAccountAddress(chainID),
-		CallTracerCollector: callTracerCollector,
-		ValidateResults:     true,
+		ChainID:         chainID,
+		RootAddr:        evm.StorageAccountAddress(chainID),
+		ValidateResults: true,
 	}
 
 	// initialize event ingestion engine
@@ -196,7 +187,6 @@ func (b *Bootstrap) StartEventIngestion(ctx context.Context) error {
 		b.storages.Blocks,
 		b.storages.Receipts,
 		b.storages.Transactions,
-		b.storages.Traces,
 		b.publishers.Block,
 		b.publishers.Logs,
 		b.logger,

services/ingestion/engine.go

@@ -47,7 +47,6 @@ type Engine struct {
 	blocks          storage.BlockIndexer
 	receipts        storage.ReceiptIndexer
 	transactions    storage.TransactionIndexer
-	traces          storage.TraceIndexer
 	log             zerolog.Logger
 	evmLastHeight   *models.SequentialHeight
 	blocksPublisher *models.Publisher[*models.Block]
@@ -64,7 +63,6 @@ func NewEventIngestionEngine(
 	blocks storage.BlockIndexer,
 	receipts storage.ReceiptIndexer,
 	transactions storage.TransactionIndexer,
-	traces storage.TraceIndexer,
 	blocksPublisher *models.Publisher[*models.Block],
 	logsPublisher *models.Publisher[[]*gethTypes.Log],
 	log zerolog.Logger,
@@ -83,7 +81,6 @@ func NewEventIngestionEngine(
 		blocks:          blocks,
 		receipts:        receipts,
 		transactions:    transactions,
-		traces:          traces,
 		log:             log,
 		blocksPublisher: blocksPublisher,
 		logsPublisher:   logsPublisher,
@@ -242,7 +239,7 @@ func (e *Engine) indexEvents(events *models.CadenceEvents, batch *pebbleDB.Batch
 		e.registerStore,
 		e.blocksProvider,
 		e.log,
-		e.replayerConfig.CallTracerCollector.TxTracer(),
+		nil,
 		e.replayerConfig.ValidateResults,
 	)
 
@@ -293,20 +290,6 @@ func (e *Engine) indexEvents(events *models.CadenceEvents, batch *pebbleDB.Batch
 		return fmt.Errorf("failed to index receipts for block %d event: %w", events.Block().Height, err)
 	}
 
-	traceCollector := e.replayerConfig.CallTracerCollector
-	for _, tx := range events.Transactions() {
-		txHash := tx.Hash()
-		traceResult, err := traceCollector.Collect(txHash)
-		if err != nil {
-			return err
-		}
-
-		err = e.traces.StoreTransaction(txHash, traceResult, batch)
-		if err != nil {
-			return err
-		}
-	}
-
 	blockCreation := time.Unix(int64(events.Block().Timestamp), 0)
 	e.collector.BlockIngestionTime(blockCreation)
 

services/ingestion/engine_test.go

@@ -3,7 +3,6 @@ package ingestion
 import (
 	"context"
 	"encoding/hex"
-	"encoding/json"
 	"math/big"
 	"testing"
 
@@ -53,8 +52,6 @@ func TestSerialBlockIngestion(t *testing.T) {
 			}).
 			Once() // make sure this isn't called multiple times
 
-		traces := &storageMock.TraceIndexer{}
-
 		eventsChan := make(chan models.BlockEvents)
 
 		subscriber := &mocks.EventSubscriber{}
@@ -66,13 +63,12 @@ func TestSerialBlockIngestion(t *testing.T) {
 
 		engine := NewEventIngestionEngine(
 			subscriber,
-			replayer.NewBlocksProvider(blocks, flowGo.Emulator, nil),
+			replayer.NewBlocksProvider(blocks, flowGo.Emulator),
 			store,
 			registerStore,
 			blocks,
 			receipts,
 			transactions,
-			traces,
 			models.NewPublisher[*models.Block](),
 			models.NewPublisher[[]*gethTypes.Log](),
 			zerolog.Nop(),
@@ -133,8 +129,6 @@ func TestSerialBlockIngestion(t *testing.T) {
 			}).
 			Once() // make sure this isn't called multiple times
 
-		traces := &storageMock.TraceIndexer{}
-
 		eventsChan := make(chan models.BlockEvents)
 		subscriber := &mocks.EventSubscriber{}
 		subscriber.
@@ -145,13 +139,12 @@ func TestSerialBlockIngestion(t *testing.T) {
 
 		engine := NewEventIngestionEngine(
 			subscriber,
-			replayer.NewBlocksProvider(blocks, flowGo.Emulator, nil),
+			replayer.NewBlocksProvider(blocks, flowGo.Emulator),
 			store,
 			registerStore,
 			blocks,
 			receipts,
 			transactions,
-			traces,
 			models.NewPublisher[*models.Block](),
 			models.NewPublisher[[]*gethTypes.Log](),
 			zerolog.Nop(),
@@ -256,23 +249,14 @@ func TestBlockAndTransactionIngestion(t *testing.T) {
 		blockCdc, block, blockEvent, err := newBlock(nextHeight, []gethCommon.Hash{result.TxHash})
 		require.NoError(t, err)
 
-		traces := &storageMock.TraceIndexer{}
-		traces.
-			On("StoreTransaction", mock.AnythingOfType("common.Hash"), mock.AnythingOfType("json.RawMessage"), mock.Anything).
-			Return(func(txID gethCommon.Hash, trace json.RawMessage, batch *pebbleDB.Batch) error {
-				assert.Equal(t, transaction.Hash(), txID)
-				return nil
-			})
-
 		engine := NewEventIngestionEngine(
 			subscriber,
-			replayer.NewBlocksProvider(blocks, flowGo.Emulator, nil),
+			replayer.NewBlocksProvider(blocks, flowGo.Emulator),
 			store,
 			registerStore,
 			blocks,
 			receipts,
 			transactions,
-			traces,
 			models.NewPublisher[*models.Block](),
 			models.NewPublisher[[]*gethTypes.Log](),
 			zerolog.Nop(),
@@ -359,28 +343,19 @@ func TestBlockAndTransactionIngestion(t *testing.T) {
 				return eventsChan
 			})
 
-		txCdc, txEvent, transaction, res, err := newTransaction(nextHeight)
+		txCdc, txEvent, _, res, err := newTransaction(nextHeight)
 		require.NoError(t, err)
 		blockCdc, _, blockEvent, err := newBlock(nextHeight, []gethCommon.Hash{res.TxHash})
 		require.NoError(t, err)
 
-		traces := &storageMock.TraceIndexer{}
-		traces.
-			On("StoreTransaction", mock.AnythingOfType("common.Hash"), mock.AnythingOfType("json.RawMessage"), mock.Anything).
-			Return(func(txID gethCommon.Hash, trace json.RawMessage, batch *pebbleDB.Batch) error {
-				assert.Equal(t, transaction.Hash(), txID)
-				return nil
-			})
-
 		engine := NewEventIngestionEngine(
 			subscriber,
-			replayer.NewBlocksProvider(blocks, flowGo.Emulator, nil),
+			replayer.NewBlocksProvider(blocks, flowGo.Emulator),
 			store,
 			registerStore,
 			blocks,
 			receipts,
 			transactions,
-			traces,
 			models.NewPublisher[*models.Block](),
 			models.NewPublisher[[]*gethTypes.Log](),
 			zerolog.Nop(),
@@ -455,8 +430,6 @@ func TestBlockAndTransactionIngestion(t *testing.T) {
 			}).
 			Once() // make sure this isn't called multiple times
 
-		traces := &storageMock.TraceIndexer{}
-
 		eventsChan := make(chan models.BlockEvents)
 		subscriber := &mocks.EventSubscriber{}
 		subscriber.
@@ -468,13 +441,12 @@ func TestBlockAndTransactionIngestion(t *testing.T) {
 
 		engine := NewEventIngestionEngine(
 			subscriber,
-			replayer.NewBlocksProvider(blocks, flowGo.Emulator, nil),
+			replayer.NewBlocksProvider(blocks, flowGo.Emulator),
 			store,
 			registerStore,
 			blocks,
 			receipts,
 			transactions,
-			traces,
 			models.NewPublisher[*models.Block](),
 			models.NewPublisher[[]*gethTypes.Log](),
 			zerolog.Nop(),
@@ -517,13 +489,6 @@ func TestBlockAndTransactionIngestion(t *testing.T) {
 				Return(func(receipts []*models.Receipt, _ *pebbleDB.Batch) error { return nil }).
 				Once()
 
-			traces.
-				On("StoreTransaction", mock.AnythingOfType("common.Hash"), mock.AnythingOfType("json.RawMessage"), mock.Anything).
-				Return(func(txID gethCommon.Hash, trace json.RawMessage, batch *pebbleDB.Batch) error {
-					assert.Equal(t, transaction.Hash(), txID)
-					return nil
-				})
-
 			events = append(events, flow.Event{
 				Type:  string(txEvent.Etype),
 				Value: txCdc,
@@ -628,10 +593,9 @@ func newTransaction(height uint64) (cadence.Event, *events.Event, models.Transac
 
 func defaultReplayerConfig() replayer.Config {
 	return replayer.Config{
-		ChainID:             flowGo.Emulator,
-		RootAddr:            evm.StorageAccountAddress(flowGo.Emulator),
-		CallTracerCollector: replayer.NopTracer,
-		ValidateResults:     false,
+		ChainID:         flowGo.Emulator,
+		RootAddr:        evm.StorageAccountAddress(flowGo.Emulator),
+		ValidateResults: false,
 	}
 }
 

services/replayer/blocks_provider.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 
 	gethCommon "github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/eth/tracers"
 	"github.com/onflow/flow-evm-gateway/models"
 	"github.com/onflow/flow-evm-gateway/storage"
 	"github.com/onflow/flow-go/fvm/evm/offchain/blocks"
@@ -37,7 +36,7 @@ func (bs *blockSnapshot) BlockContext() (evmTypes.BlockContext, error) {
 			return blockHash
 		},
 		bs.block.PrevRandao,
-		bs.tracer,
+		nil,
 	)
 }
 
@@ -51,7 +50,6 @@ func (bs *blockSnapshot) BlockContext() (evmTypes.BlockContext, error) {
 type BlocksProvider struct {
 	blocks      storage.BlockIndexer
 	chainID     flowGo.ChainID
-	tracer      *tracers.Tracer
 	latestBlock *models.Block
 }
 
@@ -60,12 +58,10 @@ var _ evmTypes.BlockSnapshotProvider = (*BlocksProvider)(nil)
 func NewBlocksProvider(
 	blocks storage.BlockIndexer,
 	chainID flowGo.ChainID,
-	tracer *tracers.Tracer,
 ) *BlocksProvider {
 	return &BlocksProvider{
 		blocks:  blocks,
 		chainID: chainID,
-		tracer:  tracer,
 	}
 }