op-challenger: Remove l2Client and rollupClient from RegisterTask API (#13770)

Makes RegisterTask generic enough to support interop games

op-challenger/game/fault/register.go

@@ -14,6 +14,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-challenger/game/scheduler"
 	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
 	"github.com/ethereum-optimism/optimism/op-service/clock"
+	"github.com/ethereum-optimism/optimism/op-service/dial"
 	"github.com/ethereum-optimism/optimism/op-service/sources/batching"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
@@ -52,7 +53,6 @@ func RegisterGameTypes(
 	cfg *config.Config,
 	registry Registry,
 	oracles OracleRegistry,
-	rollupClient RollupClient,
 	txSender TxSender,
 	gameFactory *contracts.DisputeGameFactoryContract,
 	caller *batching.MultiCaller,
@@ -64,31 +64,41 @@ func RegisterGameTypes(
 	if err != nil {
 		return nil, fmt.Errorf("dial l2 client %v: %w", cfg.L2Rpc, err)
 	}
+	closer := l2Client.Close
+
+	rollupClient, err := dial.DialRollupClientWithTimeout(ctx, dial.DefaultDialTimeout, logger, cfg.RollupRpc)
+	if err != nil {
+		return closer, fmt.Errorf("dial rollup client %v: %w", cfg.RollupRpc, err)
+	}
+	closer = func() {
+		l2Client.Close()
+		rollupClient.Close()
+	}
 	syncValidator := newSyncStatusValidator(rollupClient)
 
 	var registerTasks []*RegisterTask
 	if cfg.TraceTypeEnabled(faultTypes.TraceTypeCannon) {
-		registerTasks = append(registerTasks, NewCannonRegisterTask(faultTypes.CannonGameType, cfg, m, vm.NewOpProgramServerExecutor(logger)))
+		registerTasks = append(registerTasks, NewCannonRegisterTask(faultTypes.CannonGameType, cfg, m, vm.NewOpProgramServerExecutor(logger), l2Client, rollupClient))
 	}
 	if cfg.TraceTypeEnabled(faultTypes.TraceTypePermissioned) {
-		registerTasks = append(registerTasks, NewCannonRegisterTask(faultTypes.PermissionedGameType, cfg, m, vm.NewOpProgramServerExecutor(logger)))
+		registerTasks = append(registerTasks, NewCannonRegisterTask(faultTypes.PermissionedGameType, cfg, m, vm.NewOpProgramServerExecutor(logger), l2Client, rollupClient))
 	}
 	if cfg.TraceTypeEnabled(faultTypes.TraceTypeAsterisc) {
-		registerTasks = append(registerTasks, NewAsteriscRegisterTask(faultTypes.AsteriscGameType, cfg, m, vm.NewOpProgramServerExecutor(logger)))
+		registerTasks = append(registerTasks, NewAsteriscRegisterTask(faultTypes.AsteriscGameType, cfg, m, vm.NewOpProgramServerExecutor(logger), l2Client, rollupClient))
 	}
 	if cfg.TraceTypeEnabled(faultTypes.TraceTypeAsteriscKona) {
-		registerTasks = append(registerTasks, NewAsteriscKonaRegisterTask(faultTypes.AsteriscKonaGameType, cfg, m, vm.NewKonaExecutor()))
+		registerTasks = append(registerTasks, NewAsteriscKonaRegisterTask(faultTypes.AsteriscKonaGameType, cfg, m, vm.NewKonaExecutor(), l2Client, rollupClient))
 	}
 	if cfg.TraceTypeEnabled(faultTypes.TraceTypeFast) {
-		registerTasks = append(registerTasks, NewAlphabetRegisterTask(faultTypes.FastGameType))
+		registerTasks = append(registerTasks, NewAlphabetRegisterTask(faultTypes.FastGameType, l2Client, rollupClient))
 	}
 	if cfg.TraceTypeEnabled(faultTypes.TraceTypeAlphabet) {
-		registerTasks = append(registerTasks, NewAlphabetRegisterTask(faultTypes.AlphabetGameType))
+		registerTasks = append(registerTasks, NewAlphabetRegisterTask(faultTypes.AlphabetGameType, l2Client, rollupClient))
 	}
 	for _, task := range registerTasks {
-		if err := task.Register(ctx, registry, oracles, systemClock, l1Clock, logger, m, syncValidator, rollupClient, txSender, gameFactory, caller, l2Client, l1HeaderSource, selective, claimants); err != nil {
-			return nil, fmt.Errorf("failed to register %v game type: %w", task.gameType, err)
+		if err := task.Register(ctx, registry, oracles, systemClock, l1Clock, logger, m, syncValidator, txSender, gameFactory, caller, l1HeaderSource, selective, claimants); err != nil {
+			return closer, fmt.Errorf("failed to register %v game type: %w", task.gameType, err)
 		}
 	}
-	return l2Client.Close, nil
+	return closer, nil
 }

op-challenger/game/fault/register_task.go

@@ -33,14 +33,13 @@ type RegisterTask struct {
 	gameType               faultTypes.GameType
 	skipPrestateValidation bool
 
-	getPrestateProvider func(ctx context.Context, prestateHash common.Hash) (faultTypes.PrestateProvider, error)
-	newTraceAccessor    func(
+	getTopPrestateProvider    func(ctx context.Context, prestateBlock uint64) (faultTypes.PrestateProvider, error)
+	getBottomPrestateProvider func(ctx context.Context, prestateHash common.Hash) (faultTypes.PrestateProvider, error)
+	newTraceAccessor          func(
 		logger log.Logger,
 		m metrics.Metricer,
-		l2Client utils.L2HeaderSource,
 		prestateProvider faultTypes.PrestateProvider,
 		vmPrestateProvider faultTypes.PrestateProvider,
-		rollupClient outputs.OutputRollupClient,
 		dir string,
 		l1Head eth.BlockID,
 		splitDepth faultTypes.Depth,
@@ -48,7 +47,7 @@ type RegisterTask struct {
 		poststateBlock uint64) (*trace.Accessor, error)
 }
 
-func NewCannonRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor) *RegisterTask {
+func NewCannonRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor, l2Client utils.L2HeaderSource, rollupClient outputs.OutputRollupClient) *RegisterTask {
 	stateConverter := cannon.NewStateConverter(cfg.Cannon)
 	return &RegisterTask{
 		gameType: gameType,
@@ -56,7 +55,10 @@ func NewCannonRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m c
 		// Only trusted actors participate in these games so they aren't expected to reach the step() call and
 		// are often configured without valid prestates but the challenger should still resolve the games.
 		skipPrestateValidation: gameType == faultTypes.PermissionedGameType,
-		getPrestateProvider: cachePrestates(
+		getTopPrestateProvider: func(ctx context.Context, prestateBlock uint64) (faultTypes.PrestateProvider, error) {
+			return outputs.NewPrestateProvider(rollupClient, prestateBlock), nil
+		},
+		getBottomPrestateProvider: cachePrestates(
 			gameType,
 			stateConverter,
 			m,
@@ -69,10 +71,8 @@ func NewCannonRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m c
 		newTraceAccessor: func(
 			logger log.Logger,
 			m metrics.Metricer,
-			l2Client utils.L2HeaderSource,
 			prestateProvider faultTypes.PrestateProvider,
 			vmPrestateProvider faultTypes.PrestateProvider,
-			rollupClient outputs.OutputRollupClient,
 			dir string,
 			l1Head eth.BlockID,
 			splitDepth faultTypes.Depth,
@@ -84,11 +84,14 @@ func NewCannonRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m c
 	}
 }
 
-func NewAsteriscRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor) *RegisterTask {
+func NewAsteriscRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor, l2Client utils.L2HeaderSource, rollupClient outputs.OutputRollupClient) *RegisterTask {
 	stateConverter := asterisc.NewStateConverter(cfg.Asterisc)
 	return &RegisterTask{
 		gameType: gameType,
-		getPrestateProvider: cachePrestates(
+		getTopPrestateProvider: func(ctx context.Context, prestateBlock uint64) (faultTypes.PrestateProvider, error) {
+			return outputs.NewPrestateProvider(rollupClient, prestateBlock), nil
+		},
+		getBottomPrestateProvider: cachePrestates(
 			gameType,
 			stateConverter,
 			m,
@@ -101,10 +104,8 @@ func NewAsteriscRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m
 		newTraceAccessor: func(
 			logger log.Logger,
 			m metrics.Metricer,
-			l2Client utils.L2HeaderSource,
 			prestateProvider faultTypes.PrestateProvider,
 			vmPrestateProvider faultTypes.PrestateProvider,
-			rollupClient outputs.OutputRollupClient,
 			dir string,
 			l1Head eth.BlockID,
 			splitDepth faultTypes.Depth,
@@ -116,11 +117,14 @@ func NewAsteriscRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m
 	}
 }
 
-func NewAsteriscKonaRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor) *RegisterTask {
+func NewAsteriscKonaRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor, l2Client utils.L2HeaderSource, rollupClient outputs.OutputRollupClient) *RegisterTask {
 	stateConverter := asterisc.NewStateConverter(cfg.Asterisc)
 	return &RegisterTask{
 		gameType: gameType,
-		getPrestateProvider: cachePrestates(
+		getTopPrestateProvider: func(ctx context.Context, prestateBlock uint64) (faultTypes.PrestateProvider, error) {
+			return outputs.NewPrestateProvider(rollupClient, prestateBlock), nil
+		},
+		getBottomPrestateProvider: cachePrestates(
 			gameType,
 			stateConverter,
 			m,
@@ -133,10 +137,8 @@ func NewAsteriscKonaRegisterTask(gameType faultTypes.GameType, cfg *config.Confi
 		newTraceAccessor: func(
 			logger log.Logger,
 			m metrics.Metricer,
-			l2Client utils.L2HeaderSource,
 			prestateProvider faultTypes.PrestateProvider,
 			vmPrestateProvider faultTypes.PrestateProvider,
-			rollupClient outputs.OutputRollupClient,
 			dir string,
 			l1Head eth.BlockID,
 			splitDepth faultTypes.Depth,
@@ -148,19 +150,20 @@ func NewAsteriscKonaRegisterTask(gameType faultTypes.GameType, cfg *config.Confi
 	}
 }
 
-func NewAlphabetRegisterTask(gameType faultTypes.GameType) *RegisterTask {
+func NewAlphabetRegisterTask(gameType faultTypes.GameType, l2Client utils.L2HeaderSource, rollupClient outputs.OutputRollupClient) *RegisterTask {
 	return &RegisterTask{
 		gameType: gameType,
-		getPrestateProvider: func(_ context.Context, _ common.Hash) (faultTypes.PrestateProvider, error) {
+		getTopPrestateProvider: func(ctx context.Context, prestateBlock uint64) (faultTypes.PrestateProvider, error) {
+			return outputs.NewPrestateProvider(rollupClient, prestateBlock), nil
+		},
+		getBottomPrestateProvider: func(_ context.Context, _ common.Hash) (faultTypes.PrestateProvider, error) {
 			return alphabet.PrestateProvider, nil
 		},
 		newTraceAccessor: func(
 			logger log.Logger,
 			m metrics.Metricer,
-			l2Client utils.L2HeaderSource,
 			prestateProvider faultTypes.PrestateProvider,
 			vmPrestateProvider faultTypes.PrestateProvider,
-			rollupClient outputs.OutputRollupClient,
 			dir string,
 			l1Head eth.BlockID,
 			splitDepth faultTypes.Depth,
@@ -181,13 +184,14 @@ func cachePrestates(
 	newPrestateProvider func(ctx context.Context, path string) faultTypes.PrestateProvider,
 ) func(ctx context.Context, prestateHash common.Hash) (faultTypes.PrestateProvider, error) {
 	prestateSource := prestates.NewPrestateSource(prestateBaseURL, preStatePath, prestateDir, stateConverter)
-	prestateProviderCache := prestates.NewPrestateProviderCache(m, fmt.Sprintf("prestates-%v", gameType), func(ctx context.Context, prestateHash common.Hash) (faultTypes.PrestateProvider, error) {
-		prestatePath, err := prestateSource.PrestatePath(ctx, prestateHash)
-		if err != nil {
-			return nil, fmt.Errorf("required prestate %v not available: %w", prestateHash, err)
-		}
-		return newPrestateProvider(ctx, prestatePath), nil
-	})
+	prestateProviderCache := prestates.NewPrestateProviderCache(m, fmt.Sprintf("prestates-%v", gameType),
+		func(ctx context.Context, prestateHash common.Hash) (faultTypes.PrestateProvider, error) {
+			prestatePath, err := prestateSource.PrestatePath(ctx, prestateHash)
+			if err != nil {
+				return nil, fmt.Errorf("required prestate %v not available: %w", prestateHash, err)
+			}
+			return newPrestateProvider(ctx, prestatePath), nil
+		})
 	return prestateProviderCache.GetOrCreate
 }
 
@@ -200,11 +204,9 @@ func (e *RegisterTask) Register(
 	logger log.Logger,
 	m metrics.Metricer,
 	syncValidator SyncValidator,
-	rollupClient outputs.OutputRollupClient,
 	txSender TxSender,
 	gameFactory *contracts.DisputeGameFactoryContract,
 	caller *batching.MultiCaller,
-	l2Client utils.L2HeaderSource,
 	l1HeaderSource L1HeaderSource,
 	selective bool,
 	claimants []common.Address) error {
@@ -219,7 +221,7 @@ func (e *RegisterTask) Register(
 			return nil, fmt.Errorf("failed to load prestate hash for game %v: %w", game.Proxy, err)
 		}
 
-		vmPrestateProvider, err := e.getPrestateProvider(ctx, requiredPrestatehash)
+		vmPrestateProvider, err := e.getBottomPrestateProvider(ctx, requiredPrestatehash)
 		if err != nil {
 			return nil, fmt.Errorf("required prestate %v not available for game %v: %w", requiredPrestatehash, game.Proxy, err)
 		}
@@ -241,9 +243,12 @@ func (e *RegisterTask) Register(
 		if err != nil {
 			return nil, err
 		}
-		prestateProvider := outputs.NewPrestateProvider(rollupClient, prestateBlock)
+		prestateProvider, err := e.getTopPrestateProvider(ctx, prestateBlock)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create top prestate provider: %w", err)
+		}
 		creator := func(ctx context.Context, logger log.Logger, gameDepth faultTypes.Depth, dir string) (faultTypes.TraceAccessor, error) {
-			accessor, err := e.newTraceAccessor(logger, m, l2Client, prestateProvider, vmPrestateProvider, rollupClient, dir, l1HeadID, splitDepth, prestateBlock, poststateBlock)
+			accessor, err := e.newTraceAccessor(logger, m, prestateProvider, vmPrestateProvider, dir, l1HeadID, splitDepth, prestateBlock, poststateBlock)
 			if err != nil {
 				return nil, err
 			}

op-challenger/game/service.go

@@ -10,7 +10,6 @@ import (
 	"github.com/ethereum-optimism/optimism/op-challenger/game/keccak"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/keccak/fetcher"
 	"github.com/ethereum-optimism/optimism/op-challenger/sender"
-	"github.com/ethereum-optimism/optimism/op-service/sources"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
@@ -55,7 +54,6 @@ type Service struct {
 	factoryContract *contracts.DisputeGameFactoryContract
 	registry        *registry.GameTypeRegistry
 	oracles         *registry.OracleRegistry
-	rollupClient    *sources.RollupClient
 
 	l1Client   *ethclient.Client
 	pollClient client.RPC
@@ -93,9 +91,6 @@ func (s *Service) initFromConfig(ctx context.Context, cfg *config.Config) error
 	if err := s.initL1Client(ctx, cfg); err != nil {
 		return fmt.Errorf("failed to init l1 client: %w", err)
 	}
-	if err := s.initRollupClient(ctx, cfg); err != nil {
-		return fmt.Errorf("failed to init rollup client: %w", err)
-	}
 	if err := s.initPollClient(ctx, cfg); err != nil {
 		return fmt.Errorf("failed to init poll client: %w", err)
 	}
@@ -210,27 +205,15 @@ func (s *Service) initBondClaims() error {
 	return nil
 }
 
-func (s *Service) initRollupClient(ctx context.Context, cfg *config.Config) error {
-	if cfg.RollupRpc == "" {
-		return nil
-	}
-	rollupClient, err := dial.DialRollupClientWithTimeout(ctx, dial.DefaultDialTimeout, s.logger, cfg.RollupRpc)
-	if err != nil {
-		return err
-	}
-	s.rollupClient = rollupClient
-	return nil
-}
-
 func (s *Service) registerGameTypes(ctx context.Context, cfg *config.Config) error {
 	gameTypeRegistry := registry.NewGameTypeRegistry()
 	oracles := registry.NewOracleRegistry()
 	caller := batching.NewMultiCaller(s.l1Client.Client(), batching.DefaultBatchSize)
-	closer, err := fault.RegisterGameTypes(ctx, s.systemClock, s.l1Clock, s.logger, s.metrics, cfg, gameTypeRegistry, oracles, s.rollupClient, s.txSender, s.factoryContract, caller, s.l1Client, cfg.SelectiveClaimResolution, s.claimants)
+	closer, err := fault.RegisterGameTypes(ctx, s.systemClock, s.l1Clock, s.logger, s.metrics, cfg, gameTypeRegistry, oracles, s.txSender, s.factoryContract, caller, s.l1Client, cfg.SelectiveClaimResolution, s.claimants)
+	s.faultGamesCloser = closer
 	if err != nil {
 		return err
 	}
-	s.faultGamesCloser = closer
 	s.registry = gameTypeRegistry
 	s.oracles = oracles
 	return nil
@@ -304,9 +287,6 @@ func (s *Service) Stop(ctx context.Context) error {
 		s.txMgr.Close()
 	}
 
-	if s.rollupClient != nil {
-		s.rollupClient.Close()
-	}
 	if s.pollClient != nil {
 		s.pollClient.Close()
 	}