Merge branch 'develop' into aj/challenger-server-in-docker

op-challenger/game/fault/player.go

@@ -18,9 +18,7 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 )
 
-type Actor interface {
-	Act(ctx context.Context) error
-}
+type actor func(ctx context.Context) error
 
 type GameInfo interface {
 	GetGameStatus(context.Context) (types.GameStatus, error)
@@ -28,7 +26,7 @@ type GameInfo interface {
 }
 
 type GamePlayer struct {
-	agent                   Actor
+	act                     actor
 	agreeWithProposedOutput bool
 	loader                  GameInfo
 	logger                  log.Logger
@@ -53,6 +51,25 @@ func NewGamePlayer(
 
 	loader := NewLoader(contract)
 
+	status, err := loader.GetGameStatus(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch game status: %w", err)
+	}
+	if status != types.GameStatusInProgress {
+		logger.Info("Game already resolved", "status", status)
+		// Game is already complete so skip creating the trace provider, loading game inputs etc.
+		return &GamePlayer{
+			logger:                  logger,
+			loader:                  loader,
+			agreeWithProposedOutput: cfg.AgreeWithProposedOutput,
+			completed:               true,
+			// Act function does nothing because the game is already complete
+			act: func(ctx context.Context) error {
+				return nil
+			},
+		}, nil
+	}
+
 	gameDepth, err := loader.FetchGameDepth(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch the game depth: %w", err)
@@ -88,10 +105,11 @@ func NewGamePlayer(
 	}
 
 	return &GamePlayer{
-		agent:                   NewAgent(loader, int(gameDepth), provider, responder, updater, cfg.AgreeWithProposedOutput, logger),
+		act:                     NewAgent(loader, int(gameDepth), provider, responder, updater, cfg.AgreeWithProposedOutput, logger).Act,
 		agreeWithProposedOutput: cfg.AgreeWithProposedOutput,
 		loader:                  loader,
 		logger:                  logger,
+		completed:               status != types.GameStatusInProgress,
 	}, nil
 }
 
@@ -102,7 +120,7 @@ func (g *GamePlayer) ProgressGame(ctx context.Context) bool {
 		return true
 	}
 	g.logger.Trace("Checking if actions are required")
-	if err := g.agent.Act(ctx); err != nil {
+	if err := g.act(ctx); err != nil {
 		g.logger.Error("Error when acting on game", "err", err)
 	}
 	if status, err := g.loader.GetGameStatus(ctx); err != nil {

op-challenger/game/fault/player_test.go

@@ -157,7 +157,7 @@ func setupProgressGameTest(t *testing.T, agreeWithProposedRoot bool) (*testlog.C
 	logger.SetHandler(handler)
 	gameState := &stubGameState{claimCount: 1}
 	game := &GamePlayer{
-		agent:                   gameState,
+		act:                     gameState.Act,
 		agreeWithProposedOutput: agreeWithProposedRoot,
 		loader:                  gameState,
 		logger:                  logger,

specs/rollup-node-p2p.md

@@ -147,7 +147,7 @@ TODO: the connection gater does currently not gate by IP address on the dial Acc
 
 #### Transport security
 
-[Libp2p-noise][libp2p-noise], `XX` handshake, with the the `secp256k1` P2P identity, as popularized in Eth2.
+[Libp2p-noise][libp2p-noise], `XX` handshake, with the `secp256k1` P2P identity, as popularized in Eth2.
 The TLS option is available as well, but `noise` should be prioritized in negotiation.
 
 #### Protocol negotiation