op-challenger: Only play game specified with --game-address when specified

op-challenger/fault/monitor.go

@@ -27,15 +27,17 @@ type gameMonitor struct {
 	source           gameSource
 	createGame       gameCreator
 	fetchBlockNumber blockNumberFetcher
+	allowedGame      common.Address
 	games            map[common.Address]gameAgent
 }
 
-func newGameMonitor(logger log.Logger, fetchBlockNumber blockNumberFetcher, source gameSource, createGame gameCreator) *gameMonitor {
+func newGameMonitor(logger log.Logger, fetchBlockNumber blockNumberFetcher, allowedGame common.Address, source gameSource, createGame gameCreator) *gameMonitor {
 	return &gameMonitor{
 		logger:           logger,
 		source:           source,
 		createGame:       createGame,
 		fetchBlockNumber: fetchBlockNumber,
+		allowedGame:      allowedGame,
 		games:            make(map[common.Address]gameAgent),
 	}
 }
@@ -50,6 +52,10 @@ func (m *gameMonitor) progressGames(ctx context.Context) error {
 		return fmt.Errorf("failed to load games: %w", err)
 	}
 	for _, game := range games {
+		if m.allowedGame != (common.Address{}) && m.allowedGame != game.Proxy {
+			m.logger.Debug("Skipping game not on allow list", "game", game.Proxy)
+			continue
+		}
 		if err := m.progressGame(ctx, game); err != nil {
 			m.logger.Error("Error while progressing game", "game", game.Proxy, "err", err)
 		}

op-challenger/fault/monitor_test.go

@@ -13,7 +13,7 @@ import (
 )
 
 func TestMonitorExitsWhenContextDone(t *testing.T) {
-	monitor, _, _ := setupMonitorTest(t)
+	monitor, _, _ := setupMonitorTest(t, common.Address{})
 	ctx, cancel := context.WithCancel(context.Background())
 	cancel()
 	err := monitor.MonitorGames(ctx)
@@ -21,7 +21,7 @@ func TestMonitorExitsWhenContextDone(t *testing.T) {
 }
 
 func TestMonitorCreateAndProgressGameAgents(t *testing.T) {
-	monitor, source, games := setupMonitorTest(t)
+	monitor, source, games := setupMonitorTest(t, common.Address{})
 
 	addr1 := common.Address{0xaa}
 	addr2 := common.Address{0xbb}
@@ -51,7 +51,32 @@ func TestMonitorCreateAndProgressGameAgents(t *testing.T) {
 	require.Equal(t, 2, games.created[addr2].progressCount)
 }
 
-func setupMonitorTest(t *testing.T) (*gameMonitor, *stubGameSource, *createdGames) {
+func TestMonitorOnlyCreateSpecifiedGame(t *testing.T) {
+	addr1 := common.Address{0xaa}
+	addr2 := common.Address{0xbb}
+	monitor, source, games := setupMonitorTest(t, addr2)
+
+	source.games = []FaultDisputeGame{
+		{
+			Proxy:     addr1,
+			Timestamp: big.NewInt(9999),
+		},
+		{
+			Proxy:     addr2,
+			Timestamp: big.NewInt(9999),
+		},
+	}
+
+	err := monitor.progressGames(context.Background())
+	require.NoError(t, err)
+
+	require.Len(t, games.created, 1, "should only create allowed game")
+	require.Contains(t, games.created, addr2)
+	require.NotContains(t, games.created, addr1)
+	require.Equal(t, 1, games.created[addr2].progressCount)
+}
+
+func setupMonitorTest(t *testing.T, allowedGame common.Address) (*gameMonitor, *stubGameSource, *createdGames) {
 	logger := testlog.Logger(t, log.LvlDebug)
 	source := &stubGameSource{}
 	games := &createdGames{
@@ -61,7 +86,7 @@ func setupMonitorTest(t *testing.T) (*gameMonitor, *stubGameSource, *createdGame
 	fetchBlockNum := func(ctx context.Context) (uint64, error) {
 		return 1234, nil
 	}
-	monitor := newGameMonitor(logger, fetchBlockNum, source, games.CreateGame)
+	monitor := newGameMonitor(logger, fetchBlockNum, allowedGame, source, games.CreateGame)
 	return monitor, source, games
 }
 

op-challenger/fault/service.go

@@ -46,7 +46,7 @@ func NewService(ctx context.Context, logger log.Logger, cfg *config.Config) (*se
 	}
 	loader := NewGameLoader(factory)
 
-	monitor := newGameMonitor(logger, client.BlockNumber, loader, func(addr common.Address) (gameAgent, error) {
+	monitor := newGameMonitor(logger, client.BlockNumber, cfg.GameAddress, loader, func(addr common.Address) (gameAgent, error) {
 		return NewGame(ctx, logger, cfg, addr, txMgr, client)
 	})
 	return &service{
@@ -74,5 +74,5 @@ func ValidateAbsolutePrestate(ctx context.Context, trace types.TraceProvider, lo
 
 // MonitorGame monitors the fault dispute game and attempts to progress it.
 func (s *service) MonitorGame(ctx context.Context) error {
-	return s.monitor.MonitorGames(ctx) // TODO MonitorGame(ctx, s.logger, s.agreeWithProposedOutput, s.agent, s.caller)
+	return s.monitor.MonitorGames(ctx)
 }