feat(op-challenger): Highest Acted L1 Block Number Gauge Metric (#8724)

* feat(op-challenger): Added l1 block number gauge metric

* fix acted block metric

* challenger cleanup

op-challenger/game/monitor.go

@@ -27,7 +27,7 @@ type gameSource interface {
 }
 
 type gameScheduler interface {
-	Schedule([]types.GameMetadata) error
+	Schedule([]types.GameMetadata, uint64) error
 }
 
 type gameMonitor struct {
@@ -101,7 +101,7 @@ func (m *gameMonitor) minGameTimestamp() uint64 {
 	return 0
 }
 
-func (m *gameMonitor) progressGames(ctx context.Context, blockHash common.Hash) error {
+func (m *gameMonitor) progressGames(ctx context.Context, blockHash common.Hash, blockNumber uint64) error {
 	games, err := m.source.FetchAllGamesAtBlock(ctx, m.minGameTimestamp(), blockHash)
 	if err != nil {
 		return fmt.Errorf("failed to load games: %w", err)
@@ -114,7 +114,7 @@ func (m *gameMonitor) progressGames(ctx context.Context, blockHash common.Hash)
 		}
 		gamesToPlay = append(gamesToPlay, game)
 	}
-	if err := m.scheduler.Schedule(gamesToPlay); errors.Is(err, scheduler.ErrBusy) {
+	if err := m.scheduler.Schedule(gamesToPlay, blockNumber); errors.Is(err, scheduler.ErrBusy) {
 		m.logger.Info("Scheduler still busy with previous update")
 	} else if err != nil {
 		return fmt.Errorf("failed to schedule games: %w", err)
@@ -123,7 +123,7 @@ func (m *gameMonitor) progressGames(ctx context.Context, blockHash common.Hash)
 }
 
 func (m *gameMonitor) onNewL1Head(ctx context.Context, sig eth.L1BlockRef) {
-	if err := m.progressGames(ctx, sig.Hash); err != nil {
+	if err := m.progressGames(ctx, sig.Hash, sig.Number); err != nil {
 		m.logger.Error("Failed to progress games", "err", err)
 	}
 }

op-challenger/game/monitor_test.go

@@ -148,7 +148,7 @@ func TestMonitorCreateAndProgressGameAgents(t *testing.T) {
 	addr2 := common.Address{0xbb}
 	source.games = []types.GameMetadata{newFDG(addr1, 9999), newFDG(addr2, 9999)}
 
-	require.NoError(t, monitor.progressGames(context.Background(), common.Hash{0x01}))
+	require.NoError(t, monitor.progressGames(context.Background(), common.Hash{0x01}, 0))
 
 	require.Len(t, sched.Scheduled(), 1)
 	require.Equal(t, []common.Address{addr1, addr2}, sched.Scheduled()[0])
@@ -160,7 +160,7 @@ func TestMonitorOnlyScheduleSpecifiedGame(t *testing.T) {
 	monitor, source, sched, _ := setupMonitorTest(t, []common.Address{addr2})
 	source.games = []types.GameMetadata{newFDG(addr1, 9999), newFDG(addr2, 9999)}
 
-	require.NoError(t, monitor.progressGames(context.Background(), common.Hash{0x01}))
+	require.NoError(t, monitor.progressGames(context.Background(), common.Hash{0x01}, 0))
 
 	require.Len(t, sched.Scheduled(), 1)
 	require.Equal(t, []common.Address{addr2}, sched.Scheduled()[0])
@@ -271,7 +271,7 @@ func (s *stubScheduler) Scheduled() [][]common.Address {
 	defer s.Unlock()
 	return s.scheduled
 }
-func (s *stubScheduler) Schedule(games []types.GameMetadata) error {
+func (s *stubScheduler) Schedule(games []types.GameMetadata, blockNumber uint64) error {
 	s.Lock()
 	defer s.Unlock()
 	var addrs []common.Address

op-challenger/game/scheduler/coordinator.go

@@ -16,10 +16,18 @@ var errUnknownGame = errors.New("unknown game")
 
 type PlayerCreator func(game types.GameMetadata, dir string) (GamePlayer, error)
 
+type CoordinatorMetricer interface {
+	RecordActedL1Block(n uint64)
+	RecordGamesStatus(inProgress, defenderWon, challengerWon int)
+	RecordGameUpdateScheduled()
+	RecordGameUpdateCompleted()
+}
+
 type gameState struct {
-	player   GamePlayer
-	inflight bool
-	status   types.GameStatus
+	player                GamePlayer
+	inflight              bool
+	lastProcessedBlockNum uint64
+	status                types.GameStatus
 }
 
 // coordinator manages the set of current games, queues games to be played (on separate worker threads) and
@@ -33,10 +41,13 @@ type coordinator struct {
 	resultQueue <-chan job
 
 	logger       log.Logger
-	m            SchedulerMetricer
+	m            CoordinatorMetricer
 	createPlayer PlayerCreator
 	states       map[common.Address]*gameState
 	disk         DiskManager
+
+	// lastScheduledBlockNum is the highest block number that the coordinator has seen and scheduled jobs.
+	lastScheduledBlockNum uint64
 }
 
 // schedule takes the current list of games to attempt to progress, filters out games that have previous
@@ -44,7 +55,7 @@ type coordinator struct {
 // To avoid deadlock, it may process results from the inbound resultQueue while adding jobs to the outbound jobQueue.
 // Returns an error if a game couldn't be scheduled because of an error. It will continue attempting to progress
 // all games even if an error occurs with one game.
-func (c *coordinator) schedule(ctx context.Context, games []types.GameMetadata) error {
+func (c *coordinator) schedule(ctx context.Context, games []types.GameMetadata, blockNumber uint64) error {
 	// First remove any game states we no longer require
 	for addr, state := range c.states {
 		if !state.inflight && !slices.ContainsFunc(games, func(candidate types.GameMetadata) bool {
@@ -63,7 +74,7 @@ func (c *coordinator) schedule(ctx context.Context, games []types.GameMetadata)
 	// Otherwise, results may start being processed before all games are recorded, resulting in existing
 	// data directories potentially being deleted for games that are required.
 	for _, game := range games {
-		if j, err := c.createJob(ctx, game); err != nil {
+		if j, err := c.createJob(ctx, game, blockNumber); err != nil {
 			errs = append(errs, fmt.Errorf("failed to create job for game %v: %w", game.Proxy, err))
 		} else if j != nil {
 			jobs = append(jobs, *j)
@@ -85,6 +96,13 @@ func (c *coordinator) schedule(ctx context.Context, games []types.GameMetadata)
 	}
 	c.m.RecordGamesStatus(gamesInProgress, gamesDefenderWon, gamesChallengerWon)
 
+	lowestProcessedBlockNum := blockNumber
+	for _, state := range c.states {
+		lowestProcessedBlockNum = min(lowestProcessedBlockNum, state.lastProcessedBlockNum)
+	}
+	c.lastScheduledBlockNum = blockNumber
+	c.m.RecordActedL1Block(lowestProcessedBlockNum)
+
 	// Finally, enqueue the jobs
 	for _, j := range jobs {
 		if err := c.enqueueJob(ctx, j); err != nil {
@@ -96,10 +114,12 @@ func (c *coordinator) schedule(ctx context.Context, games []types.GameMetadata)
 
 // createJob updates the state for the specified game and returns the job to enqueue for it, if any
 // Returns (nil, nil) when there is no error and no job to enqueue
-func (c *coordinator) createJob(ctx context.Context, game types.GameMetadata) (*job, error) {
+func (c *coordinator) createJob(ctx context.Context, game types.GameMetadata, blockNumber uint64) (*job, error) {
 	state, ok := c.states[game.Proxy]
 	if !ok {
-		state = &gameState{}
+		// This is the first time we're seeing this game, so its last processed block
+		// is the last block the coordinator processed (it didn't exist yet).
+		state = &gameState{lastProcessedBlockNum: c.lastScheduledBlockNum}
 		c.states[game.Proxy] = state
 	}
 	if state.inflight {
@@ -123,7 +143,7 @@ func (c *coordinator) createJob(ctx context.Context, game types.GameMetadata) (*
 		c.logger.Debug("Not rescheduling resolved game", "game", game.Proxy, "status", state.status)
 		return nil, nil
 	}
-	return &job{addr: game.Proxy, player: state.player, status: state.status}, nil
+	return &job{block: blockNumber, addr: game.Proxy, player: state.player, status: state.status}, nil
 }
 
 func (c *coordinator) enqueueJob(ctx context.Context, j job) error {
@@ -148,6 +168,7 @@ func (c *coordinator) processResult(j job) error {
 	}
 	state.inflight = false
 	state.status = j.status
+	state.lastProcessedBlockNum = j.block
 	c.deleteResolvedGameFiles()
 	c.m.RecordGameUpdateCompleted()
 	return nil
@@ -165,7 +186,7 @@ func (c *coordinator) deleteResolvedGameFiles() {
 	}
 }
 
-func newCoordinator(logger log.Logger, m SchedulerMetricer, jobQueue chan<- job, resultQueue <-chan job, createPlayer PlayerCreator, disk DiskManager) *coordinator {
+func newCoordinator(logger log.Logger, m CoordinatorMetricer, jobQueue chan<- job, resultQueue <-chan job, createPlayer PlayerCreator, disk DiskManager) *coordinator {
 	return &coordinator{
 		logger:       logger,
 		m:            m,

op-challenger/game/scheduler/coordinator_test.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/ethereum-optimism/optimism/op-challenger/game/scheduler/test"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/types"
-	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
 	"github.com/ethereum-optimism/optimism/op-service/testlog"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
@@ -21,7 +20,7 @@ func TestScheduleNewGames(t *testing.T) {
 	gameAddr2 := common.Address{0xbb}
 	gameAddr3 := common.Address{0xcc}
 	ctx := context.Background()
-	require.NoError(t, c.schedule(ctx, asGames(gameAddr1, gameAddr2, gameAddr3)))
+	require.NoError(t, c.schedule(ctx, asGames(gameAddr1, gameAddr2, gameAddr3), 0))
 
 	require.Len(t, workQueue, 3, "should schedule job for each game")
 	require.Len(t, games.created, 3, "should have created players")
@@ -42,11 +41,11 @@ func TestSkipSchedulingInflightGames(t *testing.T) {
 	ctx := context.Background()
 
 	// Schedule the game once
-	require.NoError(t, c.schedule(ctx, asGames(gameAddr1)))
+	require.NoError(t, c.schedule(ctx, asGames(gameAddr1), 0))
 	require.Len(t, workQueue, 1, "should schedule game")
 
 	// And then attempt to schedule again
-	require.NoError(t, c.schedule(ctx, asGames(gameAddr1)))
+	require.NoError(t, c.schedule(ctx, asGames(gameAddr1), 0))
 	require.Len(t, workQueue, 1, "should not reschedule in-flight game")
 }
 
@@ -58,7 +57,7 @@ func TestExitWhenContextDoneWhileSchedulingJob(t *testing.T) {
 	cancel() // Context is cancelled
 
 	// Should not block because the context is done.
-	err := c.schedule(ctx, asGames(gameAddr1))
+	err := c.schedule(ctx, asGames(gameAddr1), 0)
 	require.ErrorIs(t, err, context.Canceled)
 	require.Empty(t, workQueue, "should not have been able to schedule game")
 }
@@ -69,7 +68,7 @@ func TestSchedule_PrestateValidationErrors(t *testing.T) {
 	gameAddr1 := common.Address{0xaa}
 	ctx := context.Background()
 
-	err := c.schedule(ctx, asGames(gameAddr1))
+	err := c.schedule(ctx, asGames(gameAddr1), 0)
 	require.Error(t, err)
 }
 
@@ -79,7 +78,7 @@ func TestScheduleGameAgainAfterCompletion(t *testing.T) {
 	ctx := context.Background()
 
 	// Schedule the game once
-	require.NoError(t, c.schedule(ctx, asGames(gameAddr1)))
+	require.NoError(t, c.schedule(ctx, asGames(gameAddr1), 0))
 	require.Len(t, workQueue, 1, "should schedule game")
 
 	// Read the job
@@ -90,7 +89,7 @@ func TestScheduleGameAgainAfterCompletion(t *testing.T) {
 	require.NoError(t, c.processResult(j))
 
 	// And then attempt to schedule again
-	require.NoError(t, c.schedule(ctx, asGames(gameAddr1)))
+	require.NoError(t, c.schedule(ctx, asGames(gameAddr1), 0))
 	require.Len(t, workQueue, 1, "should reschedule completed game")
 }
 
@@ -124,7 +123,7 @@ func TestProcessResultsWhileJobQueueFull(t *testing.T) {
 
 	// Even though work queue length is only 1, should be able to schedule all three games
 	// by reading and processing results
-	require.NoError(t, c.schedule(ctx, asGames(gameAddr1, gameAddr2, gameAddr3)))
+	require.NoError(t, c.schedule(ctx, asGames(gameAddr1, gameAddr2, gameAddr3), 0))
 	require.Len(t, games.created, 3, "should have created 3 games")
 
 loop:
@@ -150,7 +149,7 @@ func TestDeleteDataForResolvedGames(t *testing.T) {
 	ctx := context.Background()
 
 	// First get game 3 marked as resolved
-	require.NoError(t, c.schedule(ctx, asGames(gameAddr3)))
+	require.NoError(t, c.schedule(ctx, asGames(gameAddr3), 0))
 	require.Len(t, workQueue, 1)
 	j := <-workQueue
 	j.status = types.GameStatusDefenderWon
@@ -159,7 +158,7 @@ func TestDeleteDataForResolvedGames(t *testing.T) {
 	disk.DirForGame(gameAddr3)
 
 	games := asGames(gameAddr1, gameAddr2, gameAddr3)
-	require.NoError(t, c.schedule(ctx, games))
+	require.NoError(t, c.schedule(ctx, games, 0))
 
 	// The work queue should only contain jobs for games 1 and 2
 	// A resolved game should not be scheduled for an update.
@@ -182,6 +181,100 @@ func TestDeleteDataForResolvedGames(t *testing.T) {
 	require.True(t, disk.gameDirExists[gameAddr3], "game 3 data should be preserved (inflight)")
 }
 
+func TestSchedule_RecordActedL1Block(t *testing.T) {
+	c, workQueue, _, _, _ := setupCoordinatorTest(t, 10)
+	gameAddr3 := common.Address{0xcc}
+	ctx := context.Background()
+
+	// The first game should be tracked
+	require.NoError(t, c.schedule(ctx, asGames(gameAddr3), 1))
+
+	// Process the result
+	require.Len(t, workQueue, 1)
+	j := <-workQueue
+	j.status = types.GameStatusDefenderWon
+	require.NoError(t, c.processResult(j))
+
+	// Schedule so that the metric is updated
+	require.NoError(t, c.schedule(ctx, asGames(gameAddr3), 2))
+
+	// Verify that the block number is recorded by the metricer as acted upon
+	require.Equal(t, uint64(1), c.m.(*stubSchedulerMetrics).actedL1Blocks)
+}
+
+func TestSchedule_RecordActedL1BlockMultipleGames(t *testing.T) {
+	c, workQueue, _, _, _ := setupCoordinatorTest(t, 10)
+	gameAddr1 := common.Address{0xaa}
+	gameAddr2 := common.Address{0xbb}
+	gameAddr3 := common.Address{0xcc}
+	ctx := context.Background()
+
+	games := asGames(gameAddr1, gameAddr2, gameAddr3)
+	require.NoError(t, c.schedule(ctx, games, 1))
+	require.Len(t, workQueue, 3)
+
+	// Game 1 progresses and is still in progress
+	// Game 2 progresses and is now resolved
+	// Game 3 hasn't yet progressed (update is still in flight)
+	var game3Job job
+	for i := 0; i < len(games); i++ {
+		require.Equal(t, uint64(0), c.m.(*stubSchedulerMetrics).actedL1Blocks)
+		j := <-workQueue
+		if j.addr == gameAddr2 {
+			j.status = types.GameStatusDefenderWon
+		}
+		if j.addr != gameAddr3 {
+			require.NoError(t, c.processResult(j))
+		} else {
+			game3Job = j
+		}
+	}
+
+	// Schedule so that the metric is updated
+	require.NoError(t, c.schedule(ctx, games, 2))
+
+	// Verify that block 1 isn't yet complete
+	require.Equal(t, uint64(0), c.m.(*stubSchedulerMetrics).actedL1Blocks)
+
+	// Complete processing game 3
+	require.NoError(t, c.processResult(game3Job))
+
+	// Schedule so that the metric is updated
+	require.NoError(t, c.schedule(ctx, games, 3))
+
+	// Verify that block 1 is now complete
+	require.Equal(t, uint64(1), c.m.(*stubSchedulerMetrics).actedL1Blocks)
+}
+
+func TestSchedule_RecordActedL1BlockNewGame(t *testing.T) {
+	c, workQueue, _, _, _ := setupCoordinatorTest(t, 10)
+	gameAddr1 := common.Address{0xaa}
+	gameAddr2 := common.Address{0xbb}
+	gameAddr3 := common.Address{0xcc}
+	ctx := context.Background()
+
+	require.NoError(t, c.schedule(ctx, asGames(gameAddr1, gameAddr2), 1))
+	require.Len(t, workQueue, 2)
+
+	// Game 1 progresses and is still in progress
+	// Game 2 progresses and is now resolved
+	// Game 3 doesn't exist yet
+	for i := 0; i < 2; i++ {
+		require.Equal(t, uint64(0), c.m.(*stubSchedulerMetrics).actedL1Blocks)
+		j := <-workQueue
+		if j.addr == gameAddr2 {
+			j.status = types.GameStatusDefenderWon
+		}
+		require.NoError(t, c.processResult(j))
+	}
+
+	// Schedule next block with game 3 now created
+	require.NoError(t, c.schedule(ctx, asGames(gameAddr1, gameAddr2, gameAddr3), 2))
+
+	// Verify that block 1 is now complete
+	require.Equal(t, uint64(1), c.m.(*stubSchedulerMetrics).actedL1Blocks)
+}
+
 func TestDoNotDeleteDataForGameThatFailedToCreatePlayer(t *testing.T) {
 	c, workQueue, _, games, disk := setupCoordinatorTest(t, 10)
 	gameAddr1 := common.Address{0xaa}
@@ -191,7 +284,7 @@ func TestDoNotDeleteDataForGameThatFailedToCreatePlayer(t *testing.T) {
 	games.creationFails = gameAddr1
 
 	gameList := asGames(gameAddr1, gameAddr2)
-	err := c.schedule(ctx, gameList)
+	err := c.schedule(ctx, gameList, 0)
 	require.Error(t, err)
 
 	// Game 1 won't be scheduled because the player failed to be created
@@ -205,7 +298,7 @@ func TestDoNotDeleteDataForGameThatFailedToCreatePlayer(t *testing.T) {
 
 	// Should create player for game 1 next time its scheduled
 	games.creationFails = common.Address{}
-	require.NoError(t, c.schedule(ctx, gameList))
+	require.NoError(t, c.schedule(ctx, gameList, 0))
 	require.Len(t, workQueue, len(gameList), "should schedule all games")
 
 	j := <-workQueue
@@ -222,7 +315,7 @@ func TestDropOldGameStates(t *testing.T) {
 	ctx := context.Background()
 
 	// Start tracking game 1, 2 and 3
-	require.NoError(t, c.schedule(ctx, asGames(gameAddr1, gameAddr2, gameAddr3)))
+	require.NoError(t, c.schedule(ctx, asGames(gameAddr1, gameAddr2, gameAddr3), 0))
 	require.Len(t, workQueue, 3, "should schedule games")
 
 	// Complete processing of games 1 and 2, leaving 3 in flight
@@ -230,7 +323,7 @@ func TestDropOldGameStates(t *testing.T) {
 	require.NoError(t, c.processResult(<-workQueue))
 
 	// Next update only has games 2 and 4
-	require.NoError(t, c.schedule(ctx, asGames(gameAddr2, gameAddr4)))
+	require.NoError(t, c.schedule(ctx, asGames(gameAddr2, gameAddr4), 0))
 
 	require.NotContains(t, c.states, gameAddr1, "should drop state for game 1")
 	require.Contains(t, c.states, gameAddr2, "should keep state for game 2 (still active)")
@@ -247,7 +340,7 @@ func setupCoordinatorTest(t *testing.T, bufferSize int) (*coordinator, <-chan jo
 		created: make(map[common.Address]*test.StubGamePlayer),
 	}
 	disk := &stubDiskManager{gameDirExists: make(map[common.Address]bool)}
-	c := newCoordinator(logger, metrics.NoopMetrics, workQueue, resultQueue, games.CreateGame, disk)
+	c := newCoordinator(logger, &stubSchedulerMetrics{}, workQueue, resultQueue, games.CreateGame, disk)
 	return c, workQueue, resultQueue, games, disk
 }
 
@@ -283,6 +376,18 @@ func (c *createdGames) CreateGame(fdg types.GameMetadata, dir string) (GamePlaye
 	return game, nil
 }
 
+type stubSchedulerMetrics struct {
+	actedL1Blocks uint64
+}
+
+func (s *stubSchedulerMetrics) RecordActedL1Block(n uint64) {
+	s.actedL1Blocks = n
+}
+
+func (s *stubSchedulerMetrics) RecordGamesStatus(_, _, _ int) {}
+func (s *stubSchedulerMetrics) RecordGameUpdateScheduled()    {}
+func (s *stubSchedulerMetrics) RecordGameUpdateCompleted()    {}
+
 type stubDiskManager struct {
 	gameDirExists map[common.Address]bool
 	deletedDirs   []common.Address

op-challenger/game/scheduler/scheduler.go

@@ -12,6 +12,7 @@ import (
 var ErrBusy = errors.New("busy scheduling previous update")
 
 type SchedulerMetricer interface {
+	RecordActedL1Block(n uint64)
 	RecordGamesStatus(inProgress, defenderWon, challengerWon int)
 	RecordGameUpdateScheduled()
 	RecordGameUpdateCompleted()
@@ -21,12 +22,17 @@ type SchedulerMetricer interface {
 	DecIdleExecutors()
 }
 
+type blockGames struct {
+	blockNumber uint64
+	games       []types.GameMetadata
+}
+
 type Scheduler struct {
 	logger         log.Logger
 	coordinator    *coordinator
 	m              SchedulerMetricer
 	maxConcurrency uint
-	scheduleQueue  chan []types.GameMetadata
+	scheduleQueue  chan blockGames
 	jobQueue       chan job
 	resultQueue    chan job
 	wg             sync.WaitGroup
@@ -41,7 +47,7 @@ func NewScheduler(logger log.Logger, m SchedulerMetricer, disk DiskManager, maxC
 
 	// scheduleQueue has a size of 1 so backpressure quickly propagates to the caller
 	// allowing them to potentially skip update cycles.
-	scheduleQueue := make(chan []types.GameMetadata, 1)
+	scheduleQueue := make(chan blockGames, 1)
 
 	return &Scheduler{
 		logger:         logger,
@@ -84,9 +90,9 @@ func (s *Scheduler) Close() error {
 	return nil
 }
 
-func (s *Scheduler) Schedule(games []types.GameMetadata) error {
+func (s *Scheduler) Schedule(games []types.GameMetadata, blockNumber uint64) error {
 	select {
-	case s.scheduleQueue <- games:
+	case s.scheduleQueue <- blockGames{blockNumber: blockNumber, games: games}:
 		return nil
 	default:
 		return ErrBusy
@@ -99,8 +105,8 @@ func (s *Scheduler) loop(ctx context.Context) {
 		select {
 		case <-ctx.Done():
 			return
-		case games := <-s.scheduleQueue:
-			if err := s.coordinator.schedule(ctx, games); err != nil {
+		case blockGames := <-s.scheduleQueue:
+			if err := s.coordinator.schedule(ctx, blockGames.games, blockGames.blockNumber); err != nil {
 				s.logger.Error("Failed to schedule game updates", "err", err)
 			}
 		case j := <-s.resultQueue:

op-challenger/game/scheduler/scheduler_test.go

@@ -29,7 +29,7 @@ func TestSchedulerProcessesGames(t *testing.T) {
 	gameAddr3 := common.Address{0xcc}
 	games := asGames(gameAddr1, gameAddr2, gameAddr3)
 
-	require.NoError(t, s.Schedule(games))
+	require.NoError(t, s.Schedule(games, 0))
 
 	// All jobs should be executed and completed, the last step being to clean up disk resources
 	for i := 0; i < len(games); i++ {
@@ -52,10 +52,10 @@ func TestReturnBusyWhenScheduleQueueFull(t *testing.T) {
 	s := NewScheduler(logger, metrics.NoopMetrics, disk, 2, createPlayer)
 
 	// Scheduler not started - first call fills the queue
-	require.NoError(t, s.Schedule(asGames(common.Address{0xaa})))
+	require.NoError(t, s.Schedule(asGames(common.Address{0xaa}), 0))
 
 	// Second call should return busy
-	err := s.Schedule(asGames(common.Address{0xaa}))
+	err := s.Schedule(asGames(common.Address{0xaa}), 0)
 	require.ErrorIs(t, err, ErrBusy)
 }
 

op-challenger/game/scheduler/types.go

@@ -20,6 +20,7 @@ type DiskManager interface {
 }
 
 type job struct {
+	block  uint64
 	addr   common.Address
 	player GamePlayer
 	status types.GameStatus

op-challenger/metrics/metrics.go

@@ -28,6 +28,8 @@ type Metricer interface {
 	// Record cache metrics
 	caching.Metrics
 
+	RecordActedL1Block(n uint64)
+
 	RecordGameStep()
 	RecordGameMove()
 	RecordCannonExecutionTime(t float64)
@@ -57,6 +59,8 @@ type Metrics struct {
 
 	executors prometheus.GaugeVec
 
+	highestActedL1Block prometheus.Gauge
+
 	moves prometheus.Counter
 	steps prometheus.Counter
 
@@ -125,6 +129,11 @@ func NewMetrics() *Metrics {
 		}, []string{
 			"status",
 		}),
+		highestActedL1Block: factory.NewGauge(prometheus.GaugeOpts{
+			Namespace: Namespace,
+			Name:      "highest_acted_l1_block",
+			Help:      "Highest L1 block acted on by the challenger",
+		}),
 		inflightGames: factory.NewGauge(prometheus.GaugeOpts{
 			Namespace: Namespace,
 			Name:      "inflight_games",
@@ -195,6 +204,10 @@ func (m *Metrics) RecordGamesStatus(inProgress, defenderWon, challengerWon int)
 	m.trackedGames.WithLabelValues("challenger_won").Set(float64(challengerWon))
 }
 
+func (m *Metrics) RecordActedL1Block(n uint64) {
+	m.highestActedL1Block.Set(float64(n))
+}
+
 func (m *Metrics) RecordGameUpdateScheduled() {
 	m.inflightGames.Add(1)
 }

op-challenger/metrics/noop.go

@@ -26,6 +26,8 @@ func (*NoopMetricsImpl) RecordUp()                 {}
 func (*NoopMetricsImpl) RecordGameMove() {}
 func (*NoopMetricsImpl) RecordGameStep() {}
 
+func (*NoopMetricsImpl) RecordActedL1Block(_ uint64) {}
+
 func (*NoopMetricsImpl) RecordCannonExecutionTime(t float64) {}
 
 func (*NoopMetricsImpl) RecordGamesStatus(inProgress, defenderWon, challengerWon int) {}