op-challenger: Tie trace provider creation to the registered game type, not...

op-challenger: Tie trace provider creation to the registered game type, not the configured trace type.

op-challenger/game/fault/player.go

@@ -8,8 +8,6 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-challenger/config"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/responder"
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/alphabet"
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/cannon"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
 	gameTypes "github.com/ethereum-optimism/optimism/op-challenger/game/types"
 	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
@@ -34,6 +32,8 @@ type GamePlayer struct {
 	status                  gameTypes.GameStatus
 }
 
+type resourceCreator func(addr common.Address, gameDepth uint64, dir string) (types.TraceProvider, types.OracleUpdater, error)
+
 func NewGamePlayer(
 	ctx context.Context,
 	logger log.Logger,
@@ -43,6 +43,7 @@ func NewGamePlayer(
 	addr common.Address,
 	txMgr txmgr.TxManager,
 	client bind.ContractCaller,
+	creator resourceCreator,
 ) (*GamePlayer, error) {
 	logger = logger.New("game", addr)
 	contract, err := bindings.NewFaultDisputeGameCaller(addr, client)
@@ -76,24 +77,9 @@ func NewGamePlayer(
 		return nil, fmt.Errorf("failed to fetch the game depth: %w", err)
 	}
 
-	var provider types.TraceProvider
-	var updater types.OracleUpdater
-	switch cfg.TraceType {
-	case config.TraceTypeCannon:
-		cannonProvider, err := cannon.NewTraceProvider(ctx, logger, m, cfg, client, dir, addr, gameDepth)
-		if err != nil {
-			return nil, fmt.Errorf("create cannon trace provider: %w", err)
-		}
-		provider = cannonProvider
-		updater, err = cannon.NewOracleUpdater(ctx, logger, txMgr, addr, client)
-		if err != nil {
-			return nil, fmt.Errorf("failed to create the cannon updater: %w", err)
-		}
-	case config.TraceTypeAlphabet:
-		provider = alphabet.NewTraceProvider(cfg.AlphabetTrace, gameDepth)
-		updater = alphabet.NewOracleUpdater(logger)
-	default:
-		return nil, fmt.Errorf("unsupported trace type: %v", cfg.TraceType)
+	provider, updater, err := creator(addr, gameDepth, dir)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create trace provider: %w", err)
 	}
 
 	if err := ValidateAbsolutePrestate(ctx, provider, loader); err != nil {

op-challenger/game/fault/register.go

@@ -2,13 +2,18 @@ package fault
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/ethereum-optimism/optimism/op-challenger/config"
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/alphabet"
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/cannon"
+	faultTypes "github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/scheduler"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/types"
 	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
 )
 
@@ -28,16 +33,42 @@ func RegisterGameTypes(
 	m metrics.Metricer,
 	cfg *config.Config,
 	txMgr txmgr.TxManager,
-	client bind.ContractCaller) {
-	creator := func(game types.GameMetadata, dir string) (scheduler.GamePlayer, error) {
-		return NewGamePlayer(ctx, logger, m, cfg, dir, game.Proxy, txMgr, client)
-	}
+	client bind.ContractCaller,
+) {
 	switch cfg.TraceType {
 	case config.TraceTypeCannon:
-		registry.RegisterGameType(cannonGameType, creator)
-	case config.TraceTypeOutputCannon:
-		registry.RegisterGameType(cannonGameType, creator)
+		registerFaultGameType(ctx, registry, cannonGameType, logger, m, cfg, txMgr, client, func(addr common.Address, gameDepth uint64, dir string) (faultTypes.TraceProvider, faultTypes.OracleUpdater, error) {
+			provider, err := cannon.NewTraceProvider(ctx, logger, m, cfg, client, dir, addr, gameDepth)
+			if err != nil {
+				return nil, nil, fmt.Errorf("create cannon trace provider: %w", err)
+			}
+			updater, err := cannon.NewOracleUpdater(ctx, logger, txMgr, addr, client)
+			if err != nil {
+				return nil, nil, fmt.Errorf("failed to create the cannon updater: %w", err)
+			}
+			return provider, updater, nil
+		})
 	case config.TraceTypeAlphabet:
-		registry.RegisterGameType(alphabetGameType, creator)
+		registerFaultGameType(ctx, registry, alphabetGameType, logger, m, cfg, txMgr, client, func(addr common.Address, gameDepth uint64, dir string) (faultTypes.TraceProvider, faultTypes.OracleUpdater, error) {
+			provider := alphabet.NewTraceProvider(cfg.AlphabetTrace, gameDepth)
+			updater := alphabet.NewOracleUpdater(logger)
+			return provider, updater, nil
+		})
 	}
 }
+
+func registerFaultGameType(
+	ctx context.Context,
+	registry Registry,
+	gameType uint8,
+	logger log.Logger,
+	m metrics.Metricer,
+	cfg *config.Config,
+	txMgr txmgr.TxManager,
+	client bind.ContractCaller,
+	creator resourceCreator,
+) {
+	registry.RegisterGameType(gameType, func(game types.GameMetadata, dir string) (scheduler.GamePlayer, error) {
+		return NewGamePlayer(ctx, logger, m, cfg, dir, game.Proxy, txMgr, client, creator)
+	})
+}