op-challenger: Extract RegistrationTask to dedeuplicate registration code...

op-challenger: Extract RegistrationTask to dedeuplicate registration code between different game types. (#11413)

op-challenger/flags/flags.go

@@ -381,7 +381,7 @@ func CheckRequired(ctx *cli.Context, traceTypes []types.TraceType) error {
 			}
 		case types.TraceTypeAlphabet, types.TraceTypeFast:
 		default:
-			return fmt.Errorf("invalid trace type. must be one of %v", types.TraceTypes)
+			return fmt.Errorf("invalid trace type %v. must be one of %v", traceType, types.TraceTypes)
 		}
 	}
 	return nil

op-challenger/game/fault/trace/asterisc/prestate.go

@@ -39,3 +39,7 @@ func (p *AsteriscPreStateProvider) AbsolutePreStateCommitment(_ context.Context)
 	p.prestateCommitment = state.StateHash
 	return state.StateHash, nil
 }
+
+func (p *AsteriscPreStateProvider) PrestatePath() string {
+	return p.prestate
+}

op-challenger/game/fault/trace/asterisc/provider.go

@@ -177,7 +177,7 @@ func NewTraceProviderForTest(logger log.Logger, m vm.Metricer, cfg *config.Confi
 		logger:         logger,
 		dir:            dir,
 		prestate:       cfg.AsteriscAbsolutePreState,
-		generator:      vm.NewExecutor(logger, m, cfg.Asterisc, vm.NewOpProgramVmConfig(), cfg.AsteriscAbsolutePreState, localInputs),
+		generator:      vm.NewExecutor(logger, m, cfg.Asterisc, vm.NewOpProgramServerExecutor(), cfg.AsteriscAbsolutePreState, localInputs),
 		gameDepth:      gameDepth,
 		preimageLoader: utils.NewPreimageLoader(kvstore.NewDiskKV(vm.PreimageDir(dir)).Get),
 	}

op-challenger/game/fault/trace/cannon/prestate.go

@@ -41,3 +41,7 @@ func (p *CannonPrestateProvider) AbsolutePreStateCommitment(_ context.Context) (
 	p.prestateCommitment = hash
 	return hash, nil
 }
+
+func (p *CannonPrestateProvider) PrestatePath() string {
+	return p.prestate
+}

op-challenger/game/fault/trace/cannon/provider.go

@@ -181,7 +181,7 @@ func NewTraceProviderForTest(logger log.Logger, m vm.Metricer, cfg *config.Confi
 		logger:         logger,
 		dir:            dir,
 		prestate:       cfg.CannonAbsolutePreState,
-		generator:      vm.NewExecutor(logger, m, cfg.Cannon, vm.NewOpProgramVmConfig(), cfg.CannonAbsolutePreState, localInputs),
+		generator:      vm.NewExecutor(logger, m, cfg.Cannon, vm.NewOpProgramServerExecutor(), cfg.CannonAbsolutePreState, localInputs),
 		gameDepth:      gameDepth,
 		preimageLoader: utils.NewPreimageLoader(kvstore.NewDiskKV(vm.PreimageDir(dir)).Get),
 	}

op-challenger/game/fault/trace/outputs/output_cannon.go

@@ -22,7 +22,7 @@ func NewOutputCannonTraceAccessor(
 	logger log.Logger,
 	m metrics.Metricer,
 	cfg vm.Config,
-	vmCfg vm.OracleServerExecutor,
+	serverExecutor vm.OracleServerExecutor,
 	l2Client utils.L2HeaderSource,
 	prestateProvider types.PrestateProvider,
 	cannonPrestate string,
@@ -41,7 +41,7 @@ func NewOutputCannonTraceAccessor(
 		if err != nil {
 			return nil, fmt.Errorf("failed to fetch cannon local inputs: %w", err)
 		}
-		provider := cannon.NewTraceProvider(logger, m, cfg, vmCfg, prestateProvider, cannonPrestate, localInputs, subdir, depth)
+		provider := cannon.NewTraceProvider(logger, m, cfg, serverExecutor, prestateProvider, cannonPrestate, localInputs, subdir, depth)
 		return provider, nil
 	}
 

op-challenger/game/fault/trace/vm/executor_test.go

@@ -42,7 +42,7 @@ func TestGenerateProof(t *testing.T) {
 	}
 	captureExec := func(t *testing.T, cfg Config, proofAt uint64) (string, string, map[string]string) {
 		m := &stubVmMetrics{}
-		executor := NewExecutor(testlog.Logger(t, log.LevelInfo), m, cfg, NewOpProgramVmConfig(), prestate, inputs)
+		executor := NewExecutor(testlog.Logger(t, log.LevelInfo), m, cfg, NewOpProgramServerExecutor(), prestate, inputs)
 		executor.selectSnapshot = func(logger log.Logger, dir string, absolutePreState string, i uint64) (string, error) {
 			return input, nil
 		}

op-challenger/game/fault/trace/vm/kona_vm_config.go → op-challenger/game/fault/trace/vm/kona_server_executor.go

@@ -8,16 +8,16 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/chaincfg"
 )
 
-type KonaVmConfig struct {
+type KonaServerExecutor struct {
 }
 
-var _ OracleServerExecutor = (*KonaVmConfig)(nil)
+var _ OracleServerExecutor = (*KonaServerExecutor)(nil)
 
-func NewKonaVmConfig() *KonaVmConfig {
-	return &KonaVmConfig{}
+func NewKonaServerExecutor() *KonaServerExecutor {
+	return &KonaServerExecutor{}
 }
 
-func (s *KonaVmConfig) OracleCommand(cfg Config, dataDir string, inputs utils.LocalGameInputs) ([]string, error) {
+func (s *KonaServerExecutor) OracleCommand(cfg Config, dataDir string, inputs utils.LocalGameInputs) ([]string, error) {
 	if cfg.Network == "" {
 		return nil, errors.New("network is not defined")
 	}

op-challenger/game/fault/trace/vm/kona_vm_config_test.go → op-challenger/game/fault/trace/vm/kona_server_executor_test.go

@@ -26,7 +26,7 @@ func TestKonaFillHostCommand(t *testing.T) {
 		L2Claim:       common.Hash{0x44},
 		L2BlockNumber: big.NewInt(3333),
 	}
-	vmConfig := NewKonaVmConfig()
+	vmConfig := NewKonaServerExecutor()
 
 	args, err := vmConfig.OracleCommand(cfg, dir, inputs)
 	require.NoError(t, err)

op-challenger/game/fault/trace/vm/op_program_vm_config.go → op-challenger/game/fault/trace/vm/op_program_server_executor.go

@@ -4,16 +4,16 @@ import (
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/utils"
 )
 
-type OpProgramVmConfig struct {
+type OpProgramServerExecutor struct {
 }
 
-var _ OracleServerExecutor = (*OpProgramVmConfig)(nil)
+var _ OracleServerExecutor = (*OpProgramServerExecutor)(nil)
 
-func NewOpProgramVmConfig() *OpProgramVmConfig {
-	return &OpProgramVmConfig{}
+func NewOpProgramServerExecutor() *OpProgramServerExecutor {
+	return &OpProgramServerExecutor{}
 }
 
-func (s *OpProgramVmConfig) OracleCommand(cfg Config, dataDir string, inputs utils.LocalGameInputs) ([]string, error) {
+func (s *OpProgramServerExecutor) OracleCommand(cfg Config, dataDir string, inputs utils.LocalGameInputs) ([]string, error) {
 	args := []string{
 		cfg.Server, "--server",
 		"--l1", cfg.L1,

op-challenger/game/fault/trace/vm/op_program_vm_config_test.go → op-challenger/game/fault/trace/vm/op_program_server_executor_test.go

@@ -40,7 +40,7 @@ func TestOpProgramFillHostCommand(t *testing.T) {
 	}
 
 	t.Run("NoExtras", func(t *testing.T) {
-		vmConfig := NewOpProgramVmConfig()
+		vmConfig := NewOpProgramServerExecutor()
 
 		args, err := vmConfig.OracleCommand(cfg, dir, inputs)
 		require.NoError(t, err)
@@ -50,7 +50,7 @@ func TestOpProgramFillHostCommand(t *testing.T) {
 
 	t.Run("WithNetwork", func(t *testing.T) {
 		cfg.Network = "op-test"
-		vmConfig := NewOpProgramVmConfig()
+		vmConfig := NewOpProgramServerExecutor()
 
 		args, err := vmConfig.OracleCommand(cfg, dir, inputs)
 		require.NoError(t, err)
@@ -61,7 +61,7 @@ func TestOpProgramFillHostCommand(t *testing.T) {
 
 	t.Run("WithRollupConfigPath", func(t *testing.T) {
 		cfg.RollupConfigPath = "rollup.config"
-		vmConfig := NewOpProgramVmConfig()
+		vmConfig := NewOpProgramServerExecutor()
 
 		args, err := vmConfig.OracleCommand(cfg, dir, inputs)
 		require.NoError(t, err)
@@ -72,7 +72,7 @@ func TestOpProgramFillHostCommand(t *testing.T) {
 
 	t.Run("WithL2GenesisPath", func(t *testing.T) {
 		cfg.L2GenesisPath = "l2.genesis"
-		vmConfig := NewOpProgramVmConfig()
+		vmConfig := NewOpProgramServerExecutor()
 
 		args, err := vmConfig.OracleCommand(cfg, dir, inputs)
 		require.NoError(t, err)
@@ -85,7 +85,7 @@ func TestOpProgramFillHostCommand(t *testing.T) {
 		cfg.Network = "op-test"
 		cfg.RollupConfigPath = "rollup.config"
 		cfg.L2GenesisPath = "l2.genesis"
-		vmConfig := NewOpProgramVmConfig()
+		vmConfig := NewOpProgramServerExecutor()
 
 		args, err := vmConfig.OracleCommand(cfg, dir, inputs)
 		require.NoError(t, err)

op-challenger/runner/factory.go

@@ -28,7 +28,7 @@ func createTraceProvider(
 ) (types.TraceProvider, error) {
 	switch traceType {
 	case types.TraceTypeCannon:
-		vmConfig := vm.NewOpProgramVmConfig()
+		vmConfig := vm.NewOpProgramServerExecutor()
 		prestate, err := getPrestate(prestateHash, cfg.CannonAbsolutePreStateBaseURL, cfg.CannonAbsolutePreState, dir)
 		if err != nil {
 			return nil, err
@@ -36,7 +36,7 @@ func createTraceProvider(
 		prestateProvider := cannon.NewPrestateProvider(prestate)
 		return cannon.NewTraceProvider(logger, m, cfg.Cannon, vmConfig, prestateProvider, prestate, localInputs, dir, 42), nil
 	case types.TraceTypeAsterisc:
-		vmConfig := vm.NewOpProgramVmConfig()
+		vmConfig := vm.NewOpProgramServerExecutor()
 		prestate, err := getPrestate(prestateHash, cfg.AsteriscAbsolutePreStateBaseURL, cfg.AsteriscAbsolutePreState, dir)
 		if err != nil {
 			return nil, err
@@ -44,7 +44,7 @@ func createTraceProvider(
 		prestateProvider := asterisc.NewPrestateProvider(prestate)
 		return asterisc.NewTraceProvider(logger, m, cfg.Asterisc, vmConfig, prestateProvider, prestate, localInputs, dir, 42), nil
 	case types.TraceTypeAsteriscKona:
-		vmConfig := vm.NewKonaVmConfig()
+		vmConfig := vm.NewKonaServerExecutor()
 		prestate, err := getPrestate(prestateHash, cfg.AsteriscAbsolutePreStateBaseURL, cfg.AsteriscAbsolutePreState, dir)
 		if err != nil {
 			return nil, err

op-dispute-mon/mon/extract/caller.go

@@ -51,7 +51,11 @@ func (g *GameCallerCreator) CreateContract(ctx context.Context, game gameTypes.G
 		return fdg, nil
 	}
 	switch faultTypes.GameType(game.GameType) {
-	case faultTypes.CannonGameType, faultTypes.PermissionedGameType, faultTypes.AsteriscGameType, faultTypes.AlphabetGameType:
+	case faultTypes.CannonGameType,
+		faultTypes.PermissionedGameType,
+		faultTypes.AsteriscGameType,
+		faultTypes.AlphabetGameType,
+		faultTypes.FastGameType:
 		fdg, err := contracts.NewFaultDisputeGameContract(ctx, g.m, game.Proxy, g.caller)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create fault dispute game contract: %w", err)

op-dispute-mon/mon/extract/caller_test.go

@@ -31,6 +31,10 @@ func TestMetadataCreator_CreateContract(t *testing.T) {
 			name: "validCannonGameType",
 			game: types.GameMetadata{GameType: uint32(faultTypes.CannonGameType), Proxy: fdgAddr},
 		},
+		{
+			name: "validPermissionedGameType",
+			game: types.GameMetadata{GameType: uint32(faultTypes.PermissionedGameType), Proxy: fdgAddr},
+		},
 		{
 			name: "validAsteriscGameType",
 			game: types.GameMetadata{GameType: uint32(faultTypes.AsteriscGameType), Proxy: fdgAddr},
@@ -39,6 +43,10 @@ func TestMetadataCreator_CreateContract(t *testing.T) {
 			name: "validAlphabetGameType",
 			game: types.GameMetadata{GameType: uint32(faultTypes.AlphabetGameType), Proxy: fdgAddr},
 		},
+		{
+			name: "validFastGameType",
+			game: types.GameMetadata{GameType: uint32(faultTypes.FastGameType), Proxy: fdgAddr},
+		},
 		{
 			name:        "InvalidGameType",
 			game:        types.GameMetadata{GameType: 3, Proxy: fdgAddr},

op-e2e/e2eutils/disputegame/output_cannon_helper.go

@@ -63,7 +63,7 @@ func (g *OutputCannonGameHelper) CreateHonestActor(ctx context.Context, l2Node s
 	prestateProvider := outputs.NewPrestateProvider(rollupClient, prestateBlock)
 	l1Head := g.GetL1Head(ctx)
 	accessor, err := outputs.NewOutputCannonTraceAccessor(
-		logger, metrics.NoopMetrics, cfg.Cannon, vm.NewOpProgramVmConfig(), l2Client, prestateProvider, cfg.CannonAbsolutePreState, rollupClient, dir, l1Head, splitDepth, prestateBlock, poststateBlock)
+		logger, metrics.NoopMetrics, cfg.Cannon, vm.NewOpProgramServerExecutor(), l2Client, prestateProvider, cfg.CannonAbsolutePreState, rollupClient, dir, l1Head, splitDepth, prestateBlock, poststateBlock)
 	g.Require.NoError(err, "Failed to create output cannon trace accessor")
 	return NewOutputHonestHelper(g.T, g.Require, &g.OutputGameHelper, g.Game, accessor)
 }

op-e2e/faultproofs/precompile_test.go

@@ -225,7 +225,7 @@ func runCannon(t *testing.T, ctx context.Context, sys *op_e2e.System, inputs uti
 	cannonOpts(&cfg)
 
 	logger := testlog.Logger(t, log.LevelInfo).New("role", "cannon")
-	executor := vm.NewExecutor(logger, metrics.NoopMetrics, cfg.Cannon, vm.NewOpProgramVmConfig(), cfg.CannonAbsolutePreState, inputs)
+	executor := vm.NewExecutor(logger, metrics.NoopMetrics, cfg.Cannon, vm.NewOpProgramServerExecutor(), cfg.CannonAbsolutePreState, inputs)
 
 	t.Log("Running cannon")
 	err := executor.DoGenerateProof(ctx, proofsDir, math.MaxUint, math.MaxUint, extraVmArgs...)