feat(challenger): `AsteriscKona` trace type (#11140)

* feat(challenger): `AsteriscKona` trace type

Adds support for the new `asterisc-kona` game type in the
`op-challenger`

* feat: add `kona-host` `--l2-chain-id` flag

* op-challenger: Separate oracle server executor (#11348)

* fix(op-challenger): run trace cmd

* fix(op-challenger): lints

---------
Co-authored-by: Adrian Sutton <adrian@oplabs.co>
Co-authored-by: refcell <abigger87@gmail.com>

op-challenger/config/config.go

@@ -96,9 +96,12 @@ type Config struct {
 	CannonAbsolutePreStateBaseURL *url.URL // Base URL to retrieve absolute pre-states for Cannon traces from
 
 	// Specific to the asterisc trace provider
-	Asterisc                        vm.Config
-	AsteriscAbsolutePreState        string   // File to load the absolute pre-state for Asterisc traces from
-	AsteriscAbsolutePreStateBaseURL *url.URL // Base URL to retrieve absolute pre-states for Asterisc traces from
+	Asterisc                            vm.Config
+	AsteriscAbsolutePreState            string   // File to load the absolute pre-state for Asterisc traces from
+	AsteriscAbsolutePreStateBaseURL     *url.URL // Base URL to retrieve absolute pre-states for Asterisc traces from
+	AsteriscKona                        vm.Config
+	AsteriscKonaAbsolutePreState        string   // File to load the absolute pre-state for AsteriscKona traces from
+	AsteriscKonaAbsolutePreStateBaseURL *url.URL // Base URL to retrieve absolute pre-states for AsteriscKona traces from
 
 	MaxPendingTx uint64 // Maximum number of pending transactions (0 == no limit)
 
@@ -152,6 +155,14 @@ func NewConfig(
 			SnapshotFreq: DefaultAsteriscSnapshotFreq,
 			InfoFreq:     DefaultAsteriscInfoFreq,
 		},
+		AsteriscKona: vm.Config{
+			VmType:       types.TraceTypeAsteriscKona,
+			L1:           l1EthRpc,
+			L1Beacon:     l1BeaconApi,
+			L2:           l2EthRpc,
+			SnapshotFreq: DefaultAsteriscSnapshotFreq,
+			InfoFreq:     DefaultAsteriscInfoFreq,
+		},
 		GameWindow: DefaultGameWindow,
 	}
 }

op-challenger/flags/flags.go

@@ -178,17 +178,33 @@ var (
 		Usage:   "Path to executable to use as pre-image oracle server when generating trace data (asterisc trace type only)",
 		EnvVars: prefixEnvVars("ASTERISC_SERVER"),
 	}
+	AsteriscKonaServerFlag = &cli.StringFlag{
+		Name:    "asterisc-kona-server",
+		Usage:   "Path to kona executable to use as pre-image oracle server when generating trace data (asterisc-kona trace type only)",
+		EnvVars: prefixEnvVars("ASTERISC_KONA_SERVER"),
+	}
 	AsteriscPreStateFlag = &cli.StringFlag{
 		Name:    "asterisc-prestate",
 		Usage:   "Path to absolute prestate to use when generating trace data (asterisc trace type only)",
 		EnvVars: prefixEnvVars("ASTERISC_PRESTATE"),
 	}
+	AsteriscKonaPreStateFlag = &cli.StringFlag{
+		Name:    "asterisc-kona-prestate",
+		Usage:   "Path to absolute prestate to use when generating trace data (asterisc-kona trace type only)",
+		EnvVars: prefixEnvVars("ASTERISC_KONA_PRESTATE"),
+	}
 	AsteriscPreStatesURLFlag = &cli.StringFlag{
 		Name: "asterisc-prestates-url",
 		Usage: "Base URL to absolute prestates to use when generating trace data. " +
 			"Prestates in this directory should be name as <commitment>.json (asterisc trace type only)",
 		EnvVars: prefixEnvVars("ASTERISC_PRESTATES_URL"),
 	}
+	AsteriscKonaPreStatesURLFlag = &cli.StringFlag{
+		Name: "asterisc-kona-prestates-url",
+		Usage: "Base URL to absolute prestates to use when generating trace data. " +
+			"Prestates in this directory should be name as <commitment>.json (asterisc-kona trace type only)",
+		EnvVars: prefixEnvVars("ASTERISC_KONA_PRESTATES_URL"),
+	}
 	AsteriscSnapshotFreqFlag = &cli.UintFlag{
 		Name:    "asterisc-snapshot-freq",
 		Usage:   "Frequency of asterisc snapshots to generate in VM steps (asterisc trace type only)",
@@ -255,8 +271,11 @@ var optionalFlags = []cli.Flag{
 	AsteriscL2GenesisFlag,
 	AsteriscBinFlag,
 	AsteriscServerFlag,
+	AsteriscKonaServerFlag,
 	AsteriscPreStateFlag,
+	AsteriscKonaPreStateFlag,
 	AsteriscPreStatesURLFlag,
+	AsteriscKonaPreStatesURLFlag,
 	AsteriscSnapshotFreqFlag,
 	AsteriscInfoFreqFlag,
 	GameWindowFlag,
@@ -486,6 +505,14 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro
 		}
 		asteriscPreStatesURL = parsed
 	}
+	var asteriscKonaPreStatesURL *url.URL
+	if ctx.IsSet(AsteriscKonaPreStatesURLFlag.Name) {
+		parsed, err := url.Parse(ctx.String(AsteriscKonaPreStatesURLFlag.Name))
+		if err != nil {
+			return nil, fmt.Errorf("invalid asterisc-kona pre states url (%v): %w", ctx.String(AsteriscKonaPreStatesURLFlag.Name), err)
+		}
+		asteriscKonaPreStatesURL = parsed
+	}
 	l2Rpc, err := getL2Rpc(ctx, logger)
 	if err != nil {
 		return nil, err
@@ -546,10 +573,25 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro
 		},
 		AsteriscAbsolutePreState:        ctx.String(AsteriscPreStateFlag.Name),
 		AsteriscAbsolutePreStateBaseURL: asteriscPreStatesURL,
-		TxMgrConfig:                     txMgrConfig,
-		MetricsConfig:                   metricsConfig,
-		PprofConfig:                     pprofConfig,
-		SelectiveClaimResolution:        ctx.Bool(SelectiveClaimResolutionFlag.Name),
-		AllowInvalidPrestate:            ctx.Bool(UnsafeAllowInvalidPrestate.Name),
+		AsteriscKona: vm.Config{
+			VmType:           types.TraceTypeAsteriscKona,
+			L1:               l1EthRpc,
+			L1Beacon:         l1Beacon,
+			L2:               l2Rpc,
+			VmBin:            ctx.String(AsteriscBinFlag.Name),
+			Server:           ctx.String(AsteriscKonaServerFlag.Name),
+			Network:          asteriscNetwork,
+			RollupConfigPath: ctx.String(AsteriscRollupConfigFlag.Name),
+			L2GenesisPath:    ctx.String(AsteriscL2GenesisFlag.Name),
+			SnapshotFreq:     ctx.Uint(AsteriscSnapshotFreqFlag.Name),
+			InfoFreq:         ctx.Uint(AsteriscInfoFreqFlag.Name),
+		},
+		AsteriscKonaAbsolutePreState:        ctx.String(AsteriscKonaPreStateFlag.Name),
+		AsteriscKonaAbsolutePreStateBaseURL: asteriscKonaPreStatesURL,
+		TxMgrConfig:                         txMgrConfig,
+		MetricsConfig:                       metricsConfig,
+		PprofConfig:                         pprofConfig,
+		SelectiveClaimResolution:            ctx.Bool(SelectiveClaimResolutionFlag.Name),
+		AllowInvalidPrestate:                ctx.Bool(UnsafeAllowInvalidPrestate.Name),
 	}, nil
 }

op-challenger/game/fault/register.go

@@ -14,6 +14,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/outputs"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/prestates"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/utils"
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/vm"
 	faultTypes "github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
 	keccakTypes "github.com/ethereum-optimism/optimism/op-challenger/game/keccak/types"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/scheduler"
@@ -74,20 +75,29 @@ func RegisterGameTypes(
 	syncValidator := newSyncStatusValidator(rollupClient)
 
 	if cfg.TraceTypeEnabled(faultTypes.TraceTypeCannon) {
-		if err := registerCannon(faultTypes.CannonGameType, registry, oracles, ctx, systemClock, l1Clock, logger, m, cfg, syncValidator, rollupClient, txSender, gameFactory, caller, l2Client, l1HeaderSource, selective, claimants); err != nil {
+		vmConfig := vm.NewOpProgramVmConfig()
+		if err := registerCannon(faultTypes.CannonGameType, registry, oracles, ctx, systemClock, l1Clock, logger, m, cfg, vmConfig, syncValidator, rollupClient, txSender, gameFactory, caller, l2Client, l1HeaderSource, selective, claimants); err != nil {
 			return nil, fmt.Errorf("failed to register cannon game type: %w", err)
 		}
 	}
 	if cfg.TraceTypeEnabled(faultTypes.TraceTypePermissioned) {
-		if err := registerCannon(faultTypes.PermissionedGameType, registry, oracles, ctx, systemClock, l1Clock, logger, m, cfg, syncValidator, rollupClient, txSender, gameFactory, caller, l2Client, l1HeaderSource, selective, claimants); err != nil {
+		vmConfig := vm.NewOpProgramVmConfig()
+		if err := registerCannon(faultTypes.PermissionedGameType, registry, oracles, ctx, systemClock, l1Clock, logger, m, cfg, vmConfig, syncValidator, rollupClient, txSender, gameFactory, caller, l2Client, l1HeaderSource, selective, claimants); err != nil {
 			return nil, fmt.Errorf("failed to register permissioned cannon game type: %w", err)
 		}
 	}
 	if cfg.TraceTypeEnabled(faultTypes.TraceTypeAsterisc) {
-		if err := registerAsterisc(faultTypes.AsteriscGameType, registry, oracles, ctx, systemClock, l1Clock, logger, m, cfg, syncValidator, rollupClient, txSender, gameFactory, caller, l2Client, l1HeaderSource, selective, claimants); err != nil {
+		vmConfig := vm.NewOpProgramVmConfig()
+		if err := registerAsterisc(faultTypes.AsteriscGameType, registry, oracles, ctx, systemClock, l1Clock, logger, m, cfg, vmConfig, syncValidator, rollupClient, txSender, gameFactory, caller, l2Client, l1HeaderSource, selective, claimants); err != nil {
 			return nil, fmt.Errorf("failed to register asterisc game type: %w", err)
 		}
 	}
+	if cfg.TraceTypeEnabled(faultTypes.TraceTypeAsteriscKona) {
+		vmConfig := vm.NewKonaVmConfig()
+		if err := registerAsterisc(faultTypes.AsteriscKonaGameType, registry, oracles, ctx, systemClock, l1Clock, logger, m, cfg, vmConfig, syncValidator, rollupClient, txSender, gameFactory, caller, l2Client, l1HeaderSource, selective, claimants); err != nil {
+			return nil, fmt.Errorf("failed to register asterisc kona game type: %w", err)
+		}
+	}
 	if cfg.TraceTypeEnabled(faultTypes.TraceTypeFast) {
 		if err := registerAlphabet(faultTypes.FastGameType, registry, oracles, ctx, systemClock, l1Clock, logger, m, syncValidator, rollupClient, l2Client, txSender, gameFactory, caller, l1HeaderSource, selective, claimants); err != nil {
 			return nil, fmt.Errorf("failed to register fast game type: %w", err)
@@ -194,6 +204,7 @@ func registerAsterisc(
 	logger log.Logger,
 	m metrics.Metricer,
 	cfg *config.Config,
+	vmCfg vm.OracleServerExecutor,
 	syncValidator SyncValidator,
 	rollupClient outputs.OutputRollupClient,
 	txSender TxSender,
@@ -249,7 +260,7 @@ func registerAsterisc(
 			if err != nil {
 				return nil, fmt.Errorf("failed to get asterisc prestate: %w", err)
 			}
-			accessor, err := outputs.NewOutputAsteriscTraceAccessor(logger, m, cfg.Asterisc, l2Client, prestateProvider, asteriscPrestate, rollupClient, dir, l1HeadID, splitDepth, prestateBlock, poststateBlock)
+			accessor, err := outputs.NewOutputAsteriscTraceAccessor(logger, m, cfg.Asterisc, vmCfg, l2Client, prestateProvider, asteriscPrestate, rollupClient, dir, l1HeadID, splitDepth, prestateBlock, poststateBlock)
 			if err != nil {
 				return nil, err
 			}
@@ -282,6 +293,7 @@ func registerCannon(
 	logger log.Logger,
 	m metrics.Metricer,
 	cfg *config.Config,
+	vmCfg vm.OracleServerExecutor,
 	syncValidator SyncValidator,
 	rollupClient outputs.OutputRollupClient,
 	txSender TxSender,
@@ -311,7 +323,6 @@ func registerCannon(
 		}
 
 		cannonPrestateProvider, err := prestateProviderCache.GetOrCreate(requiredPrestatehash)
-
 		if err != nil {
 			return nil, fmt.Errorf("required prestate %v not available for game %v: %w", requiredPrestatehash, game.Proxy, err)
 		}
@@ -339,7 +350,7 @@ func registerCannon(
 			if err != nil {
 				return nil, fmt.Errorf("failed to get cannon prestate: %w", err)
 			}
-			accessor, err := outputs.NewOutputCannonTraceAccessor(logger, m, cfg.Cannon, l2Client, prestateProvider, cannonPrestate, rollupClient, dir, l1HeadID, splitDepth, prestateBlock, poststateBlock)
+			accessor, err := outputs.NewOutputCannonTraceAccessor(logger, m, cfg.Cannon, vmCfg, l2Client, prestateProvider, cannonPrestate, rollupClient, dir, l1HeadID, splitDepth, prestateBlock, poststateBlock)
 			if err != nil {
 				return nil, err
 			}

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

@@ -35,12 +35,12 @@ type AsteriscTraceProvider struct {
 	lastStep uint64
 }
 
-func NewTraceProvider(logger log.Logger, m vm.Metricer, cfg vm.Config, prestateProvider types.PrestateProvider, asteriscPrestate string, localInputs utils.LocalGameInputs, dir string, gameDepth types.Depth) *AsteriscTraceProvider {
+func NewTraceProvider(logger log.Logger, m vm.Metricer, cfg vm.Config, vmCfg vm.OracleServerExecutor, prestateProvider types.PrestateProvider, asteriscPrestate string, localInputs utils.LocalGameInputs, dir string, gameDepth types.Depth) *AsteriscTraceProvider {
 	return &AsteriscTraceProvider{
 		logger:           logger,
 		dir:              dir,
 		prestate:         asteriscPrestate,
-		generator:        vm.NewExecutor(logger, m, cfg, asteriscPrestate, localInputs),
+		generator:        vm.NewExecutor(logger, m, cfg, vmCfg, asteriscPrestate, localInputs),
 		gameDepth:        gameDepth,
 		preimageLoader:   utils.NewPreimageLoader(kvstore.NewDiskKV(vm.PreimageDir(dir)).Get),
 		PrestateProvider: prestateProvider,
@@ -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, cfg.AsteriscAbsolutePreState, localInputs),
+		generator:      vm.NewExecutor(logger, m, cfg.Asterisc, vm.NewOpProgramVmConfig(), cfg.AsteriscAbsolutePreState, localInputs),
 		gameDepth:      gameDepth,
 		preimageLoader: utils.NewPreimageLoader(kvstore.NewDiskKV(vm.PreimageDir(dir)).Get),
 	}

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

@@ -38,12 +38,12 @@ type CannonTraceProvider struct {
 	lastStep uint64
 }
 
-func NewTraceProvider(logger log.Logger, m vm.Metricer, cfg vm.Config, prestateProvider types.PrestateProvider, prestate string, localInputs utils.LocalGameInputs, dir string, gameDepth types.Depth) *CannonTraceProvider {
+func NewTraceProvider(logger log.Logger, m vm.Metricer, cfg vm.Config, vmCfg vm.OracleServerExecutor, prestateProvider types.PrestateProvider, prestate string, localInputs utils.LocalGameInputs, dir string, gameDepth types.Depth) *CannonTraceProvider {
 	return &CannonTraceProvider{
 		logger:           logger,
 		dir:              dir,
 		prestate:         prestate,
-		generator:        vm.NewExecutor(logger, m, cfg, prestate, localInputs),
+		generator:        vm.NewExecutor(logger, m, cfg, vmCfg, prestate, localInputs),
 		gameDepth:        gameDepth,
 		preimageLoader:   utils.NewPreimageLoader(kvstore.NewDiskKV(vm.PreimageDir(dir)).Get),
 		PrestateProvider: prestateProvider,
@@ -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, cfg.CannonAbsolutePreState, localInputs),
+		generator:      vm.NewExecutor(logger, m, cfg.Cannon, vm.NewOpProgramVmConfig(), cfg.CannonAbsolutePreState, localInputs),
 		gameDepth:      gameDepth,
 		preimageLoader: utils.NewPreimageLoader(kvstore.NewDiskKV(vm.PreimageDir(dir)).Get),
 	}

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

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

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

@@ -22,6 +22,7 @@ func NewOutputCannonTraceAccessor(
 	logger log.Logger,
 	m metrics.Metricer,
 	cfg vm.Config,
+	vmCfg vm.OracleServerExecutor,
 	l2Client utils.L2HeaderSource,
 	prestateProvider types.PrestateProvider,
 	cannonPrestate string,
@@ -40,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, prestateProvider, cannonPrestate, localInputs, subdir, depth)
+		provider := cannon.NewTraceProvider(logger, m, cfg, vmCfg, prestateProvider, cannonPrestate, localInputs, subdir, depth)
 		return provider, nil
 	}
 

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

@@ -27,22 +27,30 @@ type Metricer interface {
 }
 
 type Config struct {
-	VmType           types.TraceType
+	// VM Configuration
+	VmType       types.TraceType
+	VmBin        string // Path to the vm executable to run when generating trace data
+	SnapshotFreq uint   // Frequency of snapshots to create when executing (in VM instructions)
+	InfoFreq     uint   // Frequency of progress log messages (in VM instructions)
+	DebugInfo    bool
+
+	// Host Configuration
 	L1               string
 	L1Beacon         string
 	L2               string
-	VmBin            string // Path to the vm executable to run when generating trace data
 	Server           string // Path to the executable that provides the pre-image oracle server
 	Network          string
 	RollupConfigPath string
 	L2GenesisPath    string
-	SnapshotFreq     uint // Frequency of snapshots to create when executing (in VM instructions)
-	InfoFreq         uint // Frequency of progress log messages (in VM instructions)
-	DebugInfo        bool
+}
+
+type OracleServerExecutor interface {
+	OracleCommand(cfg Config, dataDir string, inputs utils.LocalGameInputs) ([]string, error)
 }
 
 type Executor struct {
 	cfg              Config
+	oracleServer     OracleServerExecutor
 	logger           log.Logger
 	metrics          Metricer
 	absolutePreState string
@@ -51,9 +59,10 @@ type Executor struct {
 	cmdExecutor      CmdExecutor
 }
 
-func NewExecutor(logger log.Logger, m Metricer, cfg Config, prestate string, inputs utils.LocalGameInputs) *Executor {
+func NewExecutor(logger log.Logger, m Metricer, cfg Config, oracleServer OracleServerExecutor, prestate string, inputs utils.LocalGameInputs) *Executor {
 	return &Executor{
 		cfg:              cfg,
+		oracleServer:     oracleServer,
 		logger:           logger,
 		metrics:          m,
 		inputs:           inputs,
@@ -98,28 +107,12 @@ func (e *Executor) DoGenerateProof(ctx context.Context, dir string, begin uint64
 		args = append(args, "--debug-info", filepath.Join(dataDir, debugFilename))
 	}
 	args = append(args, extraVmArgs...)
-	args = append(args,
-		"--",
-		e.cfg.Server, "--server",
-		"--l1", e.cfg.L1,
-		"--l1.beacon", e.cfg.L1Beacon,
-		"--l2", e.cfg.L2,
-		"--datadir", dataDir,
-		"--l1.head", e.inputs.L1Head.Hex(),
-		"--l2.head", e.inputs.L2Head.Hex(),
-		"--l2.outputroot", e.inputs.L2OutputRoot.Hex(),
-		"--l2.claim", e.inputs.L2Claim.Hex(),
-		"--l2.blocknumber", e.inputs.L2BlockNumber.Text(10),
-	)
-	if e.cfg.Network != "" {
-		args = append(args, "--network", e.cfg.Network)
-	}
-	if e.cfg.RollupConfigPath != "" {
-		args = append(args, "--rollup.config", e.cfg.RollupConfigPath)
-	}
-	if e.cfg.L2GenesisPath != "" {
-		args = append(args, "--l2.genesis", e.cfg.L2GenesisPath)
+	args = append(args, "--")
+	oracleArgs, err := e.oracleServer.OracleCommand(e.cfg, dataDir, e.inputs)
+	if err != nil {
+		return err
 	}
+	args = append(args, oracleArgs...)
 
 	if err := os.MkdirAll(snapshotDir, 0755); err != nil {
 		return fmt.Errorf("could not create snapshot directory %v: %w", snapshotDir, err)

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, prestate, inputs)
+		executor := NewExecutor(testlog.Logger(t, log.LevelInfo), m, cfg, NewOpProgramVmConfig(), 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

+package vm
+
+import (
+	"errors"
+	"strconv"
+
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/utils"
+	"github.com/ethereum-optimism/optimism/op-node/chaincfg"
+)
+
+type KonaVmConfig struct {
+}
+
+var _ OracleServerExecutor = (*KonaVmConfig)(nil)
+
+func NewKonaVmConfig() *KonaVmConfig {
+	return &KonaVmConfig{}
+}
+
+func (s *KonaVmConfig) OracleCommand(cfg Config, dataDir string, inputs utils.LocalGameInputs) ([]string, error) {
+	if cfg.Network == "" {
+		return nil, errors.New("network is not defined")
+	}
+
+	chainCfg := chaincfg.ChainByName(cfg.Network)
+	return []string{
+		cfg.Server, "--server",
+		"--l1-node-address", cfg.L1,
+		"--l1-beacon-address", cfg.L1Beacon,
+		"--l2-node-address", cfg.L2,
+		"--data-dir", dataDir,
+		"--l2-chain-id", strconv.FormatUint(chainCfg.ChainID, 10),
+		"--l1-head", inputs.L1Head.Hex(),
+		"--l2-head", inputs.L2Head.Hex(),
+		"--l2-output-root", inputs.L2OutputRoot.Hex(),
+		"--l2-claim", inputs.L2Claim.Hex(),
+		"--l2-block-number", inputs.L2BlockNumber.Text(10),
+	}, nil
+}

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

+package vm
+
+import (
+	"math/big"
+	"slices"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/utils"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/stretchr/testify/require"
+)
+
+func TestKonaFillHostCommand(t *testing.T) {
+	dir := "mockdir"
+	cfg := Config{
+		L1:       "http://localhost:8888",
+		L1Beacon: "http://localhost:9000",
+		L2:       "http://localhost:9999",
+		Server:   "./bin/mockserver",
+		Network:  "op-mainnet",
+	}
+	inputs := utils.LocalGameInputs{
+		L1Head:        common.Hash{0x11},
+		L2Head:        common.Hash{0x22},
+		L2OutputRoot:  common.Hash{0x33},
+		L2Claim:       common.Hash{0x44},
+		L2BlockNumber: big.NewInt(3333),
+	}
+	vmConfig := NewKonaVmConfig()
+
+	args, err := vmConfig.OracleCommand(cfg, dir, inputs)
+	require.NoError(t, err)
+
+	require.True(t, slices.Contains(args, "--server"))
+	require.True(t, slices.Contains(args, "--l1-node-address"))
+	require.True(t, slices.Contains(args, "--l1-beacon-address"))
+	require.True(t, slices.Contains(args, "--l2-node-address"))
+	require.True(t, slices.Contains(args, "--data-dir"))
+	require.True(t, slices.Contains(args, "--l2-chain-id"))
+	require.True(t, slices.Contains(args, "--l1-head"))
+	require.True(t, slices.Contains(args, "--l2-head"))
+	require.True(t, slices.Contains(args, "--l2-output-root"))
+	require.True(t, slices.Contains(args, "--l2-claim"))
+	require.True(t, slices.Contains(args, "--l2-block-number"))
+}

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

+package vm
+
+import (
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/utils"
+)
+
+type OpProgramVmConfig struct {
+}
+
+var _ OracleServerExecutor = (*OpProgramVmConfig)(nil)
+
+func NewOpProgramVmConfig() *OpProgramVmConfig {
+	return &OpProgramVmConfig{}
+}
+
+func (s *OpProgramVmConfig) OracleCommand(cfg Config, dataDir string, inputs utils.LocalGameInputs) ([]string, error) {
+	args := []string{
+		cfg.Server, "--server",
+		"--l1", cfg.L1,
+		"--l1.beacon", cfg.L1Beacon,
+		"--l2", cfg.L2,
+		"--datadir", dataDir,
+		"--l1.head", inputs.L1Head.Hex(),
+		"--l2.head", inputs.L2Head.Hex(),
+		"--l2.outputroot", inputs.L2OutputRoot.Hex(),
+		"--l2.claim", inputs.L2Claim.Hex(),
+		"--l2.blocknumber", inputs.L2BlockNumber.Text(10),
+	}
+	if cfg.Network != "" {
+		args = append(args, "--network", cfg.Network)
+	}
+	if cfg.RollupConfigPath != "" {
+		args = append(args, "--rollup.config", cfg.RollupConfigPath)
+	}
+	if cfg.L2GenesisPath != "" {
+		args = append(args, "--l2.genesis", cfg.L2GenesisPath)
+	}
+	return args, nil
+}

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

+package vm
+
+import (
+	"math/big"
+	"slices"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/utils"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/stretchr/testify/require"
+)
+
+func TestOpProgramFillHostCommand(t *testing.T) {
+	dir := "mockdir"
+	cfg := Config{
+		L1:       "http://localhost:8888",
+		L1Beacon: "http://localhost:9000",
+		L2:       "http://localhost:9999",
+		Server:   "./bin/mockserver",
+	}
+	inputs := utils.LocalGameInputs{
+		L1Head:        common.Hash{0x11},
+		L2Head:        common.Hash{0x22},
+		L2OutputRoot:  common.Hash{0x33},
+		L2Claim:       common.Hash{0x44},
+		L2BlockNumber: big.NewInt(3333),
+	}
+
+	validateStandard := func(t *testing.T, args []string) {
+		require.True(t, slices.Contains(args, "--server"))
+		require.True(t, slices.Contains(args, "--l1"))
+		require.True(t, slices.Contains(args, "--l1.beacon"))
+		require.True(t, slices.Contains(args, "--l2"))
+		require.True(t, slices.Contains(args, "--datadir"))
+		require.True(t, slices.Contains(args, "--l1.head"))
+		require.True(t, slices.Contains(args, "--l2.head"))
+		require.True(t, slices.Contains(args, "--l2.outputroot"))
+		require.True(t, slices.Contains(args, "--l2.claim"))
+		require.True(t, slices.Contains(args, "--l2.blocknumber"))
+	}
+
+	t.Run("NoExtras", func(t *testing.T) {
+		vmConfig := NewOpProgramVmConfig()
+
+		args, err := vmConfig.OracleCommand(cfg, dir, inputs)
+		require.NoError(t, err)
+
+		validateStandard(t, args)
+	})
+
+	t.Run("WithNetwork", func(t *testing.T) {
+		cfg.Network = "op-test"
+		vmConfig := NewOpProgramVmConfig()
+
+		args, err := vmConfig.OracleCommand(cfg, dir, inputs)
+		require.NoError(t, err)
+
+		validateStandard(t, args)
+		require.True(t, slices.Contains(args, "--network"))
+	})
+
+	t.Run("WithRollupConfigPath", func(t *testing.T) {
+		cfg.RollupConfigPath = "rollup.config"
+		vmConfig := NewOpProgramVmConfig()
+
+		args, err := vmConfig.OracleCommand(cfg, dir, inputs)
+		require.NoError(t, err)
+
+		validateStandard(t, args)
+		require.True(t, slices.Contains(args, "--rollup.config"))
+	})
+
+	t.Run("WithL2GenesisPath", func(t *testing.T) {
+		cfg.L2GenesisPath = "l2.genesis"
+		vmConfig := NewOpProgramVmConfig()
+
+		args, err := vmConfig.OracleCommand(cfg, dir, inputs)
+		require.NoError(t, err)
+
+		validateStandard(t, args)
+		require.True(t, slices.Contains(args, "--l2.genesis"))
+	})
+
+	t.Run("WithAllExtras", func(t *testing.T) {
+		cfg.Network = "op-test"
+		cfg.RollupConfigPath = "rollup.config"
+		cfg.L2GenesisPath = "l2.genesis"
+		vmConfig := NewOpProgramVmConfig()
+
+		args, err := vmConfig.OracleCommand(cfg, dir, inputs)
+		require.NoError(t, err)
+
+		validateStandard(t, args)
+		require.True(t, slices.Contains(args, "--network"))
+		require.True(t, slices.Contains(args, "--rollup.config"))
+		require.True(t, slices.Contains(args, "--l2.genesis"))
+	})
+}

op-challenger/game/fault/types/types.go

@@ -26,6 +26,7 @@ const (
 	CannonGameType       GameType = 0
 	PermissionedGameType GameType = 1
 	AsteriscGameType     GameType = 2
+	AsteriscKonaGameType GameType = 3
 	FastGameType         GameType = 254
 	AlphabetGameType     GameType = 255
 	UnknownGameType      GameType = math.MaxUint32
@@ -43,6 +44,8 @@ func (t GameType) String() string {
 		return "permissioned"
 	case AsteriscGameType:
 		return "asterisc"
+	case AsteriscKonaGameType:
+		return "asterisc-kona"
 	case FastGameType:
 		return "fast"
 	case AlphabetGameType:
@@ -59,6 +62,7 @@ const (
 	TraceTypeFast         TraceType = "fast"
 	TraceTypeCannon       TraceType = "cannon"
 	TraceTypeAsterisc     TraceType = "asterisc"
+	TraceTypeAsteriscKona TraceType = "asterisc-kona"
 	TraceTypePermissioned TraceType = "permissioned"
 )
 

op-challenger/runner/factory.go

@@ -28,19 +28,29 @@ func createTraceProvider(
 ) (types.TraceProvider, error) {
 	switch traceType {
 	case types.TraceTypeCannon:
+		vmConfig := vm.NewOpProgramVmConfig()
 		prestate, err := getPrestate(prestateHash, cfg.CannonAbsolutePreStateBaseURL, cfg.CannonAbsolutePreState, dir)
 		if err != nil {
 			return nil, err
 		}
 		prestateProvider := cannon.NewPrestateProvider(prestate)
-		return cannon.NewTraceProvider(logger, m, cfg.Cannon, prestateProvider, prestate, localInputs, dir, 42), nil
+		return cannon.NewTraceProvider(logger, m, cfg.Cannon, vmConfig, prestateProvider, prestate, localInputs, dir, 42), nil
 	case types.TraceTypeAsterisc:
+		vmConfig := vm.NewOpProgramVmConfig()
 		prestate, err := getPrestate(prestateHash, cfg.AsteriscAbsolutePreStateBaseURL, cfg.AsteriscAbsolutePreState, dir)
 		if err != nil {
 			return nil, err
 		}
 		prestateProvider := asterisc.NewPrestateProvider(prestate)
-		return asterisc.NewTraceProvider(logger, m, cfg.Asterisc, prestateProvider, prestate, localInputs, dir, 42), nil
+		return asterisc.NewTraceProvider(logger, m, cfg.Asterisc, vmConfig, prestateProvider, prestate, localInputs, dir, 42), nil
+	case types.TraceTypeAsteriscKona:
+		vmConfig := vm.NewKonaVmConfig()
+		prestate, err := getPrestate(prestateHash, cfg.AsteriscAbsolutePreStateBaseURL, cfg.AsteriscAbsolutePreState, dir)
+		if err != nil {
+			return nil, err
+		}
+		prestateProvider := asterisc.NewPrestateProvider(prestate)
+		return asterisc.NewTraceProvider(logger, m, cfg.Asterisc, vmConfig, prestateProvider, prestate, localInputs, dir, 42), nil
 	}
 	return nil, errors.New("invalid trace type")
 }

op-e2e/e2eutils/disputegame/output_cannon_helper.go

@@ -14,6 +14,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/outputs"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/split"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/utils"
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/vm"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
 	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
 	"github.com/ethereum-optimism/optimism/op-e2e/bindings"
@@ -62,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, l2Client, prestateProvider, cfg.CannonAbsolutePreState, rollupClient, dir, l1Head, splitDepth, prestateBlock, poststateBlock)
+		logger, metrics.NoopMetrics, cfg.Cannon, vm.NewOpProgramVmConfig(), 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

@@ -146,7 +146,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, cfg.CannonAbsolutePreState, inputs)
+	executor := vm.NewExecutor(logger, metrics.NoopMetrics, cfg.Cannon, vm.NewOpProgramVmConfig(), cfg.CannonAbsolutePreState, inputs)
 
 	t.Log("Running cannon")
 	err := executor.DoGenerateProof(ctx, proofsDir, math.MaxUint, math.MaxUint, extraVmArgs...)