Construct replayer tracer with proper chain config based on EVM height

Author: m-Peter

bootstrap/bootstrap.go

@@ -162,17 +162,13 @@ func (b *Bootstrap) StartEventIngestion(ctx context.Context) error {
 		nextCadenceHeight,
 	)
 
-	callTracerCollector, err := replayer.NewCallTracerCollector(
-		b.config.EVMNetworkID,
+	callTracerCollector := replayer.NewCallTracerCollector(
+		b.config,
 		b.logger,
 	)
-	if err != nil {
-		return err
-	}
 	blocksProvider := replayer.NewBlocksProvider(
 		b.storages.Blocks,
 		chainID,
-		callTracerCollector.TxTracer(),
 	)
 	replayerConfig := replayer.Config{
 		ChainID:             chainID,

services/ingestion/engine.go

@@ -236,13 +236,19 @@ func (e *Engine) indexEvents(events *models.CadenceEvents, batch *pebbleDB.Batch
 		return err
 	}
 
+	traceCollector := e.replayerConfig.CallTracerCollector
+	txTracer, err := traceCollector.TxTracer(events.Block().Height)
+	if err != nil {
+		return err
+	}
+
 	replayer := sync.NewReplayer(
 		e.replayerConfig.ChainID,
 		e.replayerConfig.RootAddr,
 		e.registerStore,
 		e.blocksProvider,
 		e.log,
-		e.replayerConfig.CallTracerCollector.TxTracer(),
+		txTracer,
 		e.replayerConfig.ValidateResults,
 	)
 
@@ -293,7 +299,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)

services/replayer/blocks_provider.go

@@ -10,7 +10,6 @@ import (
 	evmTypes "github.com/onflow/flow-go/fvm/evm/types"
 	flowGo "github.com/onflow/flow-go/model/flow"
 	gethCommon "github.com/onflow/go-ethereum/common"
-	"github.com/onflow/go-ethereum/eth/tracers"
 )
 
 type blockSnapshot struct {
@@ -38,7 +37,7 @@ func (bs *blockSnapshot) BlockContext() (evmTypes.BlockContext, error) {
 			return blockHash
 		},
 		bs.block.PrevRandao,
-		bs.tracer,
+		nil, // Set by the sync.ReplayBlockExecution method
 	)
 	if err != nil {
 		return evmTypes.BlockContext{}, err
@@ -59,7 +58,6 @@ func (bs *blockSnapshot) BlockContext() (evmTypes.BlockContext, error) {
 type BlocksProvider struct {
 	blocks      storage.BlockIndexer
 	chainID     flowGo.ChainID
-	tracer      *tracers.Tracer
 	latestBlock *models.Block
 }
 
@@ -68,12 +66,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,
 	}
 }
 

services/replayer/call_tracer_collector.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"math/big"
 
+	"github.com/onflow/flow-evm-gateway/config"
 	"github.com/onflow/flow-go/fvm/evm/emulator"
 	"github.com/onflow/go-ethereum/common"
 	"github.com/onflow/go-ethereum/core/tracing"
@@ -18,8 +19,11 @@ const (
 	TracerName   = "callTracer"
 )
 
-func DefaultCallTracer(evmChainID *big.Int) (*tracers.Tracer, error) {
-	evmChainConfig := emulator.MakeChainConfig(evmChainID)
+func DefaultCallTracer(evmHeight uint64, cfg config.Config) (*tracers.Tracer, error) {
+	evmChainConfig := emulator.MakeChainConfig(cfg.EVMNetworkID)
+	if !config.IsPrague(evmHeight, cfg.FlowNetworkID) {
+		evmChainConfig.PragueTime = nil
+	}
 
 	tracer, err := tracers.DefaultDirectory.New(
 		TracerName,
@@ -35,44 +39,46 @@ func DefaultCallTracer(evmChainID *big.Int) (*tracers.Tracer, error) {
 }
 
 type EVMTracer interface {
-	TxTracer() *tracers.Tracer
+	TxTracer(evmHeight uint64) (*tracers.Tracer, error)
 	ResetTracer() error
 	Collect(txID common.Hash) (json.RawMessage, error)
 }
 
 type CallTracerCollector struct {
 	tracer        *tracers.Tracer
 	resultsByTxID map[common.Hash]json.RawMessage
+	config        config.Config
 	logger        zerolog.Logger
-	evmChainID    *big.Int
+	lastEvmHeight uint64
 }
 
 var _ EVMTracer = (*CallTracerCollector)(nil)
 
-func NewCallTracerCollector(evmChainID *big.Int, logger zerolog.Logger) (
-	*CallTracerCollector,
+func NewCallTracerCollector(config config.Config, logger zerolog.Logger) *CallTracerCollector {
+	return &CallTracerCollector{
+		resultsByTxID: make(map[common.Hash]json.RawMessage),
+		config:        config,
+		logger:        logger.With().Str("component", "evm-tracer").Logger(),
+	}
+}
+
+func (t *CallTracerCollector) TxTracer(evmHeight uint64) (
+	*tracers.Tracer,
 	error,
 ) {
-	tracer, err := DefaultCallTracer(evmChainID)
+	var err error
+	t.tracer, err = DefaultCallTracer(evmHeight, t.config)
 	if err != nil {
 		return nil, err
 	}
+	t.lastEvmHeight = evmHeight
 
-	return &CallTracerCollector{
-		tracer:        tracer,
-		resultsByTxID: make(map[common.Hash]json.RawMessage),
-		logger:        logger.With().Str("component", "evm-tracer").Logger(),
-		evmChainID:    evmChainID,
-	}, nil
-}
-
-func (t *CallTracerCollector) TxTracer() *tracers.Tracer {
-	return NewSafeTxTracer(t)
+	return NewSafeTxTracer(t), nil
 }
 
 func (t *CallTracerCollector) ResetTracer() error {
 	var err error
-	t.tracer, err = DefaultCallTracer(t.evmChainID)
+	t.tracer, err = DefaultCallTracer(t.lastEvmHeight, t.config)
 	return err
 }
 
@@ -207,8 +213,8 @@ var _ EVMTracer = (*nopTracer)(nil)
 
 type nopTracer struct{}
 
-func (n nopTracer) TxTracer() *tracers.Tracer {
-	return nil
+func (n nopTracer) TxTracer(_ uint64) (*tracers.Tracer, error) {
+	return nil, nil
 }
 
 func (n nopTracer) Collect(_ common.Hash) (json.RawMessage, error) {