From 547071ff54a782aae5e51316bb09c67412fd084f Mon Sep 17 00:00:00 2001 From: Adrian Sutton Date: Mon, 22 Dec 2025 13:59:05 +1000 Subject: [PATCH 1/4] op-challenger: Remove support for SuperAsteriscKona game types. --- op-challenger/cmd/main_test.go | 113 +----------------- op-challenger/config/config.go | 12 -- op-challenger/config/config_test.go | 31 +---- op-challenger/flags/flags.go | 29 ----- op-challenger/game/fault/contracts/detect.go | 3 +- .../game/fault/contracts/disputegame.go | 2 +- .../game/fault/contracts/faultdisputegame.go | 2 +- .../fault/contracts/faultdisputegame_test.go | 2 +- op-challenger/game/fault/register.go | 7 -- op-challenger/game/fault/register_task.go | 36 ------ .../game/fault/register_task_test.go | 4 +- .../fault/trace/super/super_asterisc_kona.go | 57 --------- op-challenger/game/types/game_type.go | 19 ++- op-challenger/runner/factory.go | 9 -- op-challenger/runner/game_inputs.go | 2 +- op-dispute-mon/mon/extract/caller.go | 3 +- op-dispute-mon/mon/extract/caller_test.go | 7 +- op-dispute-mon/mon/types/types.go | 1 - 18 files changed, 21 insertions(+), 318 deletions(-) delete mode 100644 op-challenger/game/fault/trace/super/super_asterisc_kona.go diff --git a/op-challenger/cmd/main_test.go b/op-challenger/cmd/main_test.go index 0647e675f2c..100e1aa70fb 100644 --- a/op-challenger/cmd/main_test.go +++ b/op-challenger/cmd/main_test.go @@ -108,13 +108,10 @@ func TestOpSupervisor(t *testing.T) { t.Run("RequiredForSuperCannonKona", func(t *testing.T) { verifyArgsInvalid(t, "flag supervisor-rpc is required", addRequiredArgsExcept(gameTypes.SuperCannonKonaGameType, "--supervisor-rpc")) }) - t.Run("RequiredForSuperAsteriscKona", func(t *testing.T) { - verifyArgsInvalid(t, "flag supervisor-rpc is required", addRequiredArgsExcept(gameTypes.SuperAsteriscKonaGameType, "--supervisor-rpc")) - }) for _, gameType := range gameTypes.SupportedGameTypes { gameType := gameType - if gameType == gameTypes.SuperCannonGameType || gameType == gameTypes.SuperPermissionedGameType || gameType == gameTypes.SuperAsteriscKonaGameType || gameType == gameTypes.SuperCannonKonaGameType { + if gameType == gameTypes.SuperCannonGameType || gameType == gameTypes.SuperPermissionedGameType || gameType == gameTypes.SuperCannonKonaGameType { continue } @@ -140,12 +137,6 @@ func TestOpSupervisor(t *testing.T) { cfg := configForArgs(t, addRequiredArgsExcept(gameTypes.SuperCannonKonaGameType, "--supervisor-rpc", "--supervisor-rpc", url)) require.Equal(t, url, cfg.SupervisorRPC) }) - - t.Run("Valid-SuperAsteriscKona", func(t *testing.T) { - url := "http://localhost/supervisor" - cfg := configForArgs(t, addRequiredArgsExcept(gameTypes.SuperAsteriscKonaGameType, "--supervisor-rpc", "--supervisor-rpc", url)) - require.Equal(t, url, cfg.SupervisorRPC) - }) } func TestGameTypes(t *testing.T) { @@ -942,93 +933,6 @@ func TestSuperCannonKonaCustomConfigArgs(t *testing.T) { }) } -func TestSuperAsteriscKonaCustomConfigArgs(t *testing.T) { - for _, gameType := range []gameTypes.GameType{gameTypes.SuperAsteriscKonaGameType} { - gameType := gameType - - t.Run(fmt.Sprintf("TestRequireEitherAsteriscKonaNetworkOrRollupAndGenesisAndDepset-%v", gameType), func(t *testing.T) { - expectedErrorMessage := "flag network or rollup-config/asterisc-kona-rollup-config, l2-genesis/asterisc-kona-l2-genesis and depset-config/asterisc-kona-depset-config is required" - // Missing all - verifyArgsInvalid( - t, - expectedErrorMessage, - addRequiredArgsExcept(gameType, "--network")) - // Missing l2-genesis - verifyArgsInvalid( - t, - expectedErrorMessage, - addRequiredArgsExcept(gameType, "--network", "--asterisc-kona-rollup-config=rollup.json", "--asterisc-kona-depset-config=depset.json")) - // Missing rollup-config - verifyArgsInvalid( - t, - expectedErrorMessage, - addRequiredArgsExcept(gameType, "--network", "--asterisc-kona-l2-genesis=gensis.json", "--asterisc-kona-depset-config=depset.json")) - // Missing depset-config - verifyArgsInvalid( - t, - expectedErrorMessage, - addRequiredArgsExcept(gameType, "--network", "--asterisc-kona-rollup-config=rollup.json", "--asterisc-kona-l2-genesis=gensis.json")) - }) - - validateCustomNetworkFlagsProhibitedWithNetworkFlag(t, gameType, gameTypes.AsteriscKonaGameType, "asterisc-kona-l2-custom") - - t.Run(fmt.Sprintf("TestNetwork-%v", gameType), func(t *testing.T) { - t.Run("NotRequiredWhenRollupGenesisAndDepsetIsSpecified", func(t *testing.T) { - configForArgs(t, addRequiredArgsExcept(gameType, "--network", - "--asterisc-kona-rollup-config=rollup.json", "--asterisc-kona-l2-genesis=genesis.json", "--asterisc-kona-depset-config=depset.json")) - }) - - t.Run("Valid", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgsExcept(gameType, "--network", "--network", testNetwork)) - require.Equal(t, []string{testNetwork}, cfg.AsteriscKona.Networks) - }) - }) - - t.Run(fmt.Sprintf("TestSetAsteriscL2ChainId-%v", gameType), func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgsExcept(gameType, "--network", - "--asterisc-kona-rollup-config=rollup.json", - "--asterisc-kona-l2-genesis=genesis.json", - "--asterisc-kona-depset-config=depset.json", - "--asterisc-kona-l2-custom")) - require.True(t, cfg.AsteriscKona.L2Custom) - }) - - t.Run(fmt.Sprintf("TestAsteriscRollupConfig-%v", gameType), func(t *testing.T) { - t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) { - configForArgs(t, addRequiredArgsExcept(gameTypes.AlphabetGameType, "--asterisc-kona-rollup-config")) - }) - - t.Run("Valid", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgsExcept(gameType, "--network", - "--asterisc-kona-rollup-config=rollup.json", "--asterisc-kona-l2-genesis=genesis.json", "--asterisc-kona-depset-config=depset.json")) - require.Equal(t, []string{"rollup.json"}, cfg.AsteriscKona.RollupConfigPaths) - }) - }) - - t.Run(fmt.Sprintf("TestAsteriscL2Genesis-%v", gameType), func(t *testing.T) { - t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) { - configForArgs(t, addRequiredArgsExcept(gameTypes.AlphabetGameType, "--asterisc-kona-l2-genesis")) - }) - - t.Run("Valid", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgsExcept(gameType, "--network", "--asterisc-kona-rollup-config=rollup.json", "--asterisc-kona-l2-genesis=genesis.json", "--asterisc-kona-depset-config=depset.json")) - require.Equal(t, []string{"genesis.json"}, cfg.AsteriscKona.L2GenesisPaths) - }) - }) - - t.Run(fmt.Sprintf("TestAsteriscDepsetConfig-%v", gameType), func(t *testing.T) { - t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) { - configForArgs(t, addRequiredArgsExcept(gameTypes.AlphabetGameType, "--asterisc-kona-depset-config")) - }) - - t.Run("Valid", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgsExcept(gameType, "--network", "--asterisc-kona-rollup-config=rollup.json", "--asterisc-kona-l2-genesis=genesis.json", "--asterisc-kona-depset-config=depset.json")) - require.Equal(t, "depset.json", cfg.AsteriscKona.DepsetConfigPath) - }) - }) - } -} - func TestCannonRequiredArgs(t *testing.T) { for _, gameType := range []gameTypes.GameType{gameTypes.CannonGameType, gameTypes.PermissionedGameType, gameTypes.SuperCannonGameType, gameTypes.SuperPermissionedGameType} { gameType := gameType @@ -1182,12 +1086,6 @@ func TestDepsetConfig(t *testing.T) { "flag network or rollup-config/cannon-kona-rollup-config, l2-genesis/cannon-kona-l2-genesis and depset-config/cannon-kona-depset-config is required", addRequiredArgsExcept(gameType, "--network", "--rollup-config=rollup.json", "--l2-genesis=genesis.json")) }) - } else if gameType == gameTypes.SuperAsteriscKonaGameType { - t.Run("Required-"+gameType.String(), func(t *testing.T) { - verifyArgsInvalid(t, - "flag network or rollup-config/asterisc-kona-rollup-config, l2-genesis/asterisc-kona-l2-genesis and depset-config/asterisc-kona-depset-config is required", - addRequiredArgsExcept(gameType, "--network", "--rollup-config=rollup.json", "--l2-genesis=genesis.json")) - }) } else { t.Run("NotRequired-"+gameType.String(), func(t *testing.T) { cfg := configForArgs(t, addRequiredArgsExcept(gameType, "--network", "--rollup-config=rollup.json", "--l2-genesis=genesis.json")) @@ -1216,7 +1114,7 @@ func TestRollupRpc(t *testing.T) { for _, gameType := range gameTypes.SupportedGameTypes { gameType := gameType - if gameType == gameTypes.SuperCannonGameType || gameType == gameTypes.SuperPermissionedGameType || gameType == gameTypes.SuperAsteriscKonaGameType || gameType == gameTypes.SuperCannonKonaGameType { + if gameType == gameTypes.SuperCannonGameType || gameType == gameTypes.SuperPermissionedGameType || gameType == gameTypes.SuperCannonKonaGameType { t.Run(fmt.Sprintf("NotRequiredFor-%v", gameType), func(t *testing.T) { configForArgs(t, addRequiredArgsExcept(gameType, "--rollup-rpc")) }) @@ -1407,8 +1305,6 @@ func requiredArgs(gameType gameTypes.GameType) map[string]string { addRequiredSuperCannonArgs(args) case gameTypes.SuperCannonKonaGameType: addRequiredSuperCannonKonaArgs(args) - case gameTypes.SuperAsteriscKonaGameType: - addRequiredSuperAsteriscKonaArgs(args) case gameTypes.OptimisticZKGameType, gameTypes.AlphabetGameType, gameTypes.FastGameType: addRequiredOutputRootArgs(args) } @@ -1469,11 +1365,6 @@ func addRequiredAsteriscKonaArgs(args map[string]string) { args["--asterisc-kona-prestate"] = asteriscPreState } -func addRequiredSuperAsteriscKonaArgs(args map[string]string) { - addRequiredAsteriscKonaArgs(args) - args["--supervisor-rpc"] = supervisorRpc -} - func toArgList(req map[string]string) []string { var combined []string for name, value := range req { diff --git a/op-challenger/config/config.go b/op-challenger/config/config.go index fa37498de70..a62863284e6 100644 --- a/op-challenger/config/config.go +++ b/op-challenger/config/config.go @@ -353,18 +353,6 @@ func (c Config) Check() error { return err } } - if c.GameTypeEnabled(gameTypes.SuperAsteriscKonaGameType) { - if c.SupervisorRPC == "" { - return ErrMissingSupervisorRpc - } - - if len(c.AsteriscKona.Networks) == 0 && c.AsteriscKona.DepsetConfigPath == "" { - return ErrMissingDepsetConfig - } - if err := c.validateBaseAsteriscKonaOptions(); err != nil { - return err - } - } if c.GameTypeEnabled(gameTypes.OptimisticZKGameType) { if c.RollupRpc == "" { return ErrMissingRollupRpc diff --git a/op-challenger/config/config_test.go b/op-challenger/config/config_test.go index 86b38b175e1..c73348c766d 100644 --- a/op-challenger/config/config_test.go +++ b/op-challenger/config/config_test.go @@ -56,7 +56,6 @@ var allCannonGameTypes []gameTypes.GameType var cannonKonaGameTypes = []gameTypes.GameType{gameTypes.CannonKonaGameType, gameTypes.SuperCannonKonaGameType} var asteriscGameTypes = []gameTypes.GameType{gameTypes.AsteriscGameType} var asteriscKonaGameTypes = []gameTypes.GameType{gameTypes.AsteriscKonaGameType} -var superAsteriscKonaGameTypes = []gameTypes.GameType{gameTypes.SuperAsteriscKonaGameType} func init() { allCannonGameTypes = append(allCannonGameTypes, singleCannonGameTypes...) @@ -145,11 +144,6 @@ func applyValidConfigForSuperCannonKona(t *testing.T, cfg *Config) { applyValidConfigForCannonKona(t, cfg) } -func applyValidConfigForSuperAsteriscKona(t *testing.T, cfg *Config) { - cfg.SupervisorRPC = validSupervisorRpc - applyValidConfigForAsteriscKona(t, cfg) -} - func applyValidConfigForOptimisticZK(cfg *Config) { cfg.RollupRpc = validRollupRpc } @@ -174,9 +168,6 @@ func validConfig(t *testing.T, gameType gameTypes.GameType) Config { if gameType == gameTypes.AsteriscKonaGameType { applyValidConfigForAsteriscKona(t, &cfg) } - if gameType == gameTypes.SuperAsteriscKonaGameType { - applyValidConfigForSuperAsteriscKona(t, &cfg) - } if gameType == gameTypes.OptimisticZKGameType { applyValidConfigForOptimisticZK(&cfg) } @@ -518,18 +509,6 @@ func TestDepsetConfig(t *testing.T) { }) } - for _, gameType := range superAsteriscKonaGameTypes { - gameType := gameType - t.Run(fmt.Sprintf("TestAsteriscNetworkOrDepsetConfigRequired-%v", gameType), func(t *testing.T) { - cfg := validConfig(t, gameType) - cfg.AsteriscKona.Networks = nil - cfg.AsteriscKona.RollupConfigPaths = []string{"foo.json"} - cfg.AsteriscKona.L2GenesisPaths = []string{"genesis.json"} - cfg.AsteriscKona.DepsetConfigPath = "" - require.ErrorIs(t, cfg.Check(), ErrMissingDepsetConfig) - }) - } - for _, gameType := range singleCannonGameTypes { gameType := gameType t.Run(fmt.Sprintf("TestDepsetConfigNotRequired-%v", gameType), func(t *testing.T) { @@ -810,7 +789,7 @@ func TestHttpPollInterval(t *testing.T) { func TestRollupRpcRequired(t *testing.T) { for _, gameType := range gameTypes.SupportedGameTypes { gameType := gameType - if gameType == gameTypes.SuperCannonGameType || gameType == gameTypes.SuperPermissionedGameType || gameType == gameTypes.SuperAsteriscKonaGameType || gameType == gameTypes.SuperCannonKonaGameType { + if gameType == gameTypes.SuperCannonGameType || gameType == gameTypes.SuperPermissionedGameType || gameType == gameTypes.SuperCannonKonaGameType { continue } t.Run(gameType.String(), func(t *testing.T) { @@ -839,18 +818,12 @@ func TestRollupRpcNotRequiredForInterop(t *testing.T) { config.RollupRpc = "" require.NoError(t, config.Check()) }) - - t.Run("SuperAsteriscKona", func(t *testing.T) { - config := validConfig(t, gameTypes.SuperAsteriscKonaGameType) - config.RollupRpc = "" - require.NoError(t, config.Check()) - }) } func TestSupervisorRpc(t *testing.T) { for _, gameType := range gameTypes.SupportedGameTypes { gameType := gameType - if gameType == gameTypes.SuperCannonGameType || gameType == gameTypes.SuperPermissionedGameType || gameType == gameTypes.SuperAsteriscKonaGameType || gameType == gameTypes.SuperCannonKonaGameType { + if gameType == gameTypes.SuperCannonGameType || gameType == gameTypes.SuperPermissionedGameType || gameType == gameTypes.SuperCannonKonaGameType { t.Run("RequiredFor"+gameType.String(), func(t *testing.T) { config := validConfig(t, gameType) config.SupervisorRPC = "" diff --git a/op-challenger/flags/flags.go b/op-challenger/flags/flags.go index d5626fab855..be39ac13595 100644 --- a/op-challenger/flags/flags.go +++ b/op-challenger/flags/flags.go @@ -44,7 +44,6 @@ var ( gameTypes.AsteriscKonaGameType, gameTypes.SuperCannonGameType, gameTypes.SuperCannonKonaGameType, - gameTypes.SuperAsteriscKonaGameType, } // Required Flags L1EthRpcFlag = &cli.StringFlag{ @@ -526,30 +525,6 @@ func CheckAsteriscKonaFlags(ctx *cli.Context) error { return nil } -func CheckSuperAsteriscKonaFlags(ctx *cli.Context) error { - if !ctx.IsSet(SupervisorRpcFlag.Name) { - return fmt.Errorf("flag %v is required", SupervisorRpcFlag.Name) - } - if !ctx.IsSet(flags.NetworkFlagName) && - !(RollupConfigFlag.IsSet(ctx, gameTypes.AsteriscKonaGameType) && L2GenesisFlag.IsSet(ctx, gameTypes.AsteriscKonaGameType) && DepsetConfigFlag.IsSet(ctx, gameTypes.AsteriscKonaGameType)) { - return fmt.Errorf("flag %v or %v, %v and %v is required", - flags.NetworkFlagName, - RollupConfigFlag.EitherFlagName(gameTypes.AsteriscKonaGameType), - L2GenesisFlag.EitherFlagName(gameTypes.AsteriscKonaGameType), - DepsetConfigFlag.EitherFlagName(gameTypes.AsteriscKonaGameType)) - } - if err := CheckAsteriscBaseFlags(ctx, gameTypes.AsteriscKonaGameType); err != nil { - return err - } - if !ctx.IsSet(AsteriscKonaServerFlag.Name) { - return fmt.Errorf("flag %s is required", AsteriscKonaServerFlag.Name) - } - if !PreStatesURLFlag.IsSet(ctx, gameTypes.AsteriscKonaGameType) && !ctx.IsSet(AsteriscKonaPreStateFlag.Name) { - return fmt.Errorf("flag %s or %s is required", PreStatesURLFlag.EitherFlagName(gameTypes.AsteriscKonaGameType), AsteriscKonaPreStateFlag.Name) - } - return nil -} - func CheckRequired(ctx *cli.Context, types []gameTypes.GameType) error { for _, f := range requiredFlags { if !ctx.IsSet(f.Names()[0]) { @@ -585,10 +560,6 @@ func CheckRequired(ctx *cli.Context, types []gameTypes.GameType) error { if err := CheckSuperCannonKonaFlags(ctx); err != nil { return err } - case gameTypes.SuperAsteriscKonaGameType: - if err := CheckSuperAsteriscKonaFlags(ctx); err != nil { - return err - } case gameTypes.OptimisticZKGameType, gameTypes.AlphabetGameType, gameTypes.FastGameType: if err := checkOutputProviderFlags(ctx); err != nil { return err diff --git a/op-challenger/game/fault/contracts/detect.go b/op-challenger/game/fault/contracts/detect.go index 9093e88ebc1..afdee4453ba 100644 --- a/op-challenger/game/fault/contracts/detect.go +++ b/op-challenger/game/fault/contracts/detect.go @@ -38,8 +38,7 @@ func DetectGameType(ctx context.Context, addr common.Address, caller *batching.M gameTypes.AsteriscKonaGameType, gameTypes.SuperCannonGameType, gameTypes.SuperPermissionedGameType, - gameTypes.SuperCannonKonaGameType, - gameTypes.SuperAsteriscKonaGameType: + gameTypes.SuperCannonKonaGameType: return gameType, nil default: return gameTypes.UnknownGameType, fmt.Errorf("unsupported game type: %d", gameType) diff --git a/op-challenger/game/fault/contracts/disputegame.go b/op-challenger/game/fault/contracts/disputegame.go index 611e0e0cf60..09e965aeae3 100644 --- a/op-challenger/game/fault/contracts/disputegame.go +++ b/op-challenger/game/fault/contracts/disputegame.go @@ -40,7 +40,7 @@ func NewDisputeGameContractForGame(ctx context.Context, metrics metrics.Contract func NewDisputeGameContract(ctx context.Context, metrics metrics.ContractMetricer, caller *batching.MultiCaller, gameType gameTypes.GameType, addr common.Address) (DisputeGameContract, error) { switch gameType { - case gameTypes.SuperCannonGameType, gameTypes.SuperCannonKonaGameType, gameTypes.SuperPermissionedGameType, gameTypes.SuperAsteriscKonaGameType: + case gameTypes.SuperCannonGameType, gameTypes.SuperCannonKonaGameType, gameTypes.SuperPermissionedGameType: return NewSuperFaultDisputeGameContract(ctx, metrics, addr, caller) case gameTypes.CannonGameType, diff --git a/op-challenger/game/fault/contracts/faultdisputegame.go b/op-challenger/game/fault/contracts/faultdisputegame.go index d6239633c71..1408f7e6158 100644 --- a/op-challenger/game/fault/contracts/faultdisputegame.go +++ b/op-challenger/game/fault/contracts/faultdisputegame.go @@ -81,7 +81,7 @@ func NewFaultDisputeGameContract(ctx context.Context, metrics metrics.ContractMe return nil, fmt.Errorf("failed to detect game type: %w", err) } switch gameType { - case gameTypes.SuperCannonGameType, gameTypes.SuperCannonKonaGameType, gameTypes.SuperPermissionedGameType, gameTypes.SuperAsteriscKonaGameType: + case gameTypes.SuperCannonGameType, gameTypes.SuperCannonKonaGameType, gameTypes.SuperPermissionedGameType: return NewSuperFaultDisputeGameContract(ctx, metrics, addr, caller) default: return NewPreInteropFaultDisputeGameContract(ctx, metrics, addr, caller) diff --git a/op-challenger/game/fault/contracts/faultdisputegame_test.go b/op-challenger/game/fault/contracts/faultdisputegame_test.go index 9b3948deb53..4ab4938a740 100644 --- a/op-challenger/game/fault/contracts/faultdisputegame_test.go +++ b/op-challenger/game/fault/contracts/faultdisputegame_test.go @@ -52,7 +52,7 @@ func (c contractVersion) String() string { } func (c contractVersion) IsSuperGame() bool { - return c.gameType == gameTypes.SuperCannonGameType || c.gameType == gameTypes.SuperPermissionedGameType || c.gameType == gameTypes.SuperAsteriscKonaGameType + return c.gameType == gameTypes.SuperCannonGameType || c.gameType == gameTypes.SuperPermissionedGameType } const ( diff --git a/op-challenger/game/fault/register.go b/op-challenger/game/fault/register.go index 4373a371159..4cec25587a7 100644 --- a/op-challenger/game/fault/register.go +++ b/op-challenger/game/fault/register.go @@ -109,13 +109,6 @@ func RegisterGameTypes( } registerTasks = append(registerTasks, NewAsteriscKonaRegisterTask(gameTypes.AsteriscKonaGameType, cfg, m, vm.NewKonaExecutor(), l2HeaderSource, rollupClient, syncValidator)) } - if cfg.GameTypeEnabled(gameTypes.SuperAsteriscKonaGameType) { - rootProvider, syncValidator, err := clients.SuperchainClients() - if err != nil { - return err - } - registerTasks = append(registerTasks, NewSuperAsteriscKonaRegisterTask(gameTypes.SuperAsteriscKonaGameType, cfg, m, vm.NewKonaSuperExecutor(), rootProvider, syncValidator)) - } if cfg.GameTypeEnabled(gameTypes.FastGameType) { l2HeaderSource, rollupClient, syncValidator, err := clients.SingleChainClients() if err != nil { diff --git a/op-challenger/game/fault/register_task.go b/op-challenger/game/fault/register_task.go index dbd10bd2fa4..13cf104a06b 100644 --- a/op-challenger/game/fault/register_task.go +++ b/op-challenger/game/fault/register_task.go @@ -231,42 +231,6 @@ func NewAsteriscKonaRegisterTask(gameType gameTypes.GameType, cfg *config.Config } } -func NewSuperAsteriscKonaRegisterTask(gameType gameTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor, rootProvider super.RootProvider, syncValidator generic.SyncValidator) *RegisterTask { - stateConverter := asterisc.NewStateConverter(cfg.AsteriscKona) - return &RegisterTask{ - gameType: gameType, - syncValidator: syncValidator, - skipPrestateValidation: gameType == gameTypes.SuperPermissionedGameType, - getTopPrestateProvider: func(ctx context.Context, prestateTimestamp uint64) (faultTypes.PrestateProvider, error) { - return super.NewSuperRootPrestateProvider(rootProvider, prestateTimestamp), nil - }, - getBottomPrestateProvider: cachePrestates( - gameType, - stateConverter, - m, - cfg.AsteriscKonaAbsolutePreStateBaseURL, - cfg.AsteriscKonaAbsolutePreState, - filepath.Join(cfg.Datadir, "super-asterisc-kona-prestates"), - func(ctx context.Context, path string) faultTypes.PrestateProvider { - return vm.NewPrestateProvider(path, stateConverter) - }), - newTraceAccessor: func( - logger log.Logger, - m metrics.Metricer, - prestateProvider faultTypes.PrestateProvider, - vmPrestateProvider faultTypes.PrestateProvider, - dir string, - l1Head eth.BlockID, - splitDepth faultTypes.Depth, - prestateBlock uint64, - poststateBlock uint64) (*trace.Accessor, error) { - provider := vmPrestateProvider.(*vm.PrestateProvider) - preimagePrestateProvider := prestateProvider.(super.PreimagePrestateProvider) - return super.NewSuperAsteriscKonaTraceAccessor(logger, m, cfg.AsteriscKona, serverExecutor, preimagePrestateProvider, rootProvider, provider.PrestatePath(), dir, l1Head, splitDepth, prestateBlock, poststateBlock) - }, - } -} - func NewAlphabetRegisterTask(gameType gameTypes.GameType, l2Client utils.L2HeaderSource, rollupClient outputs.OutputRollupClient, syncValidator generic.SyncValidator) *RegisterTask { return &RegisterTask{ gameType: gameType, diff --git a/op-challenger/game/fault/register_task_test.go b/op-challenger/game/fault/register_task_test.go index 5eaeb15f458..65068bc5669 100644 --- a/op-challenger/game/fault/register_task_test.go +++ b/op-challenger/game/fault/register_task_test.go @@ -76,7 +76,7 @@ func TestRegisterOracle_AddsOracle(t *testing.T) { } for _, testCase := range tests { t.Run(testCase.name, func(t *testing.T) { - for _, gameType := range []gameTypes.GameType{gameTypes.CannonGameType, gameTypes.SuperCannonGameType, gameTypes.SuperAsteriscKonaGameType} { + for _, gameType := range []gameTypes.GameType{gameTypes.CannonGameType, gameTypes.SuperCannonGameType, gameTypes.SuperCannonKonaGameType} { t.Run(fmt.Sprintf("%v", gameType), func(t *testing.T) { gameFactoryAddr := common.Address{0xaa} gameImplAddr := common.Address{0xbb} @@ -86,7 +86,7 @@ func TestRegisterOracle_AddsOracle(t *testing.T) { rpc.SetResponse(gameFactoryAddr, "version", rpcblock.Latest, nil, []interface{}{testCase.version}) if gameType == gameTypes.CannonGameType { rpc.AddContract(gameImplAddr, snapshots.LoadFaultDisputeGameABI()) - } else if gameType == gameTypes.SuperCannonGameType || gameType == gameTypes.SuperAsteriscKonaGameType { + } else if gameType == gameTypes.SuperCannonGameType || gameType == gameTypes.SuperCannonKonaGameType { rpc.AddContract(gameImplAddr, snapshots.LoadSuperFaultDisputeGameABI()) } else { t.Fatalf("game type %v not supported", gameType) diff --git a/op-challenger/game/fault/trace/super/super_asterisc_kona.go b/op-challenger/game/fault/trace/super/super_asterisc_kona.go deleted file mode 100644 index 259f4c4ff66..00000000000 --- a/op-challenger/game/fault/trace/super/super_asterisc_kona.go +++ /dev/null @@ -1,57 +0,0 @@ -package super - -import ( - "context" - "fmt" - "math/big" - "path/filepath" - - "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace" - "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/asterisc" - "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-service/eth" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/common/hexutil" - "github.com/ethereum/go-ethereum/log" -) - -func NewSuperAsteriscKonaTraceAccessor( - logger log.Logger, - m metrics.Metricer, - cfg vm.Config, - serverExecutor vm.OracleServerExecutor, - prestateProvider PreimagePrestateProvider, - rootProvider RootProvider, - asteriscPrestate string, - dir string, - l1Head eth.BlockID, - splitDepth types.Depth, - prestateTimestamp uint64, - poststateTimestamp uint64, -) (*trace.Accessor, error) { - rollupCfgs, err := NewRollupConfigs(cfg) - if err != nil { - return nil, fmt.Errorf("failed to load rollup configs: %w", err) - } - outputProvider := NewSuperTraceProvider(logger, rollupCfgs, prestateProvider, rootProvider, l1Head, splitDepth, prestateTimestamp, poststateTimestamp) - asteriscCreator := func(ctx context.Context, localContext common.Hash, depth types.Depth, claimInfo ClaimInfo) (types.TraceProvider, error) { - logger := logger.New("agreedPrestate", hexutil.Bytes(claimInfo.AgreedPrestate), "claim", claimInfo.Claim, "localContext", localContext) - subdir := filepath.Join(dir, localContext.Hex()) - localInputs := utils.LocalGameInputs{ - L1Head: l1Head.Hash, - AgreedPreState: claimInfo.AgreedPrestate, - L2Claim: claimInfo.Claim, - L2SequenceNumber: new(big.Int).SetUint64(poststateTimestamp), - } - provider := asterisc.NewTraceProvider(logger, m.ToTypedVmMetrics(cfg.VmType.String()), cfg, serverExecutor, prestateProvider, asteriscPrestate, localInputs, subdir, depth) - return provider, nil - } - - cache := NewProviderCache(m, "super_asterisc_kona_provider", asteriscCreator) - selector := split.NewSplitProviderSelector(outputProvider, splitDepth, SuperRootSplitAdapter(outputProvider, cache.GetOrCreate)) - return trace.NewAccessor(selector), nil -} diff --git a/op-challenger/game/types/game_type.go b/op-challenger/game/types/game_type.go index 9e9943d0575..f1f9ed111b0 100644 --- a/op-challenger/game/types/game_type.go +++ b/op-challenger/game/types/game_type.go @@ -18,14 +18,14 @@ const ( SuperCannonGameType GameType = 4 SuperPermissionedGameType GameType = 5 OPSuccinctGameType GameType = 6 // Not supported by op-challenger - SuperAsteriscKonaGameType GameType = 7 - CannonKonaGameType GameType = 8 - SuperCannonKonaGameType GameType = 9 - OptimisticZKGameType GameType = 10 - FastGameType GameType = 254 - AlphabetGameType GameType = 255 - KailuaGameType GameType = 1337 // Not supported by op-challenger - UnknownGameType GameType = math.MaxUint32 // Not supported by op-challenger + // 7 was originally reserved for SuperAsteriscKona game type but never released. + CannonKonaGameType GameType = 8 + SuperCannonKonaGameType GameType = 9 + OptimisticZKGameType GameType = 10 + FastGameType GameType = 254 + AlphabetGameType GameType = 255 + KailuaGameType GameType = 1337 // Not supported by op-challenger + UnknownGameType GameType = math.MaxUint32 // Not supported by op-challenger ) // SupportedGameTypes is the list of game types that are supported by op-challenger. @@ -41,7 +41,6 @@ var SupportedGameTypes = []GameType{ SuperCannonGameType, SuperCannonKonaGameType, SuperPermissionedGameType, - SuperAsteriscKonaGameType, OptimisticZKGameType, } @@ -89,8 +88,6 @@ func (g GameType) String() string { return "super-permissioned" case OPSuccinctGameType: return "op-succinct" - case SuperAsteriscKonaGameType: - return "super-asterisc-kona" case CannonKonaGameType: return "cannon-kona" case SuperCannonKonaGameType: diff --git a/op-challenger/runner/factory.go b/op-challenger/runner/factory.go index 68e71d3427c..934d322ce57 100644 --- a/op-challenger/runner/factory.go +++ b/op-challenger/runner/factory.go @@ -66,15 +66,6 @@ func createTraceProvider( } prestateProvider := vm.NewPrestateProvider(prestate, stateConverter) return asterisc.NewTraceProvider(logger, m, cfg.AsteriscKona, serverExecutor, prestateProvider, prestate, localInputs, dir, 42), nil - case gameTypes.SuperAsteriscKonaGameType: - serverExecutor := vm.NewKonaSuperExecutor() - stateConverter := asterisc.NewStateConverter(cfg.AsteriscKona) - prestate, err := prestateSource.getPrestate(ctx, logger, cfg.AsteriscKonaAbsolutePreStateBaseURL, cfg.AsteriscKonaAbsolutePreState, dir, stateConverter) - if err != nil { - return nil, err - } - prestateProvider := vm.NewPrestateProvider(prestate, stateConverter) - return asterisc.NewTraceProvider(logger, m, cfg.AsteriscKona, serverExecutor, prestateProvider, prestate, localInputs, dir, 42), nil } return nil, errors.New("invalid game type") } diff --git a/op-challenger/runner/game_inputs.go b/op-challenger/runner/game_inputs.go index 2814ec5e48e..bebc9098a72 100644 --- a/op-challenger/runner/game_inputs.go +++ b/op-challenger/runner/game_inputs.go @@ -18,7 +18,7 @@ import ( func createGameInputs(ctx context.Context, log log.Logger, rollupClient *sources.RollupClient, supervisorClient *sources.SupervisorClient, typeName string, gameType gameTypes.GameType) (utils.LocalGameInputs, error) { switch gameType { - case gameTypes.SuperCannonGameType, gameTypes.SuperPermissionedGameType, gameTypes.SuperAsteriscKonaGameType, gameTypes.SuperCannonKonaGameType: + case gameTypes.SuperCannonGameType, gameTypes.SuperPermissionedGameType, gameTypes.SuperCannonKonaGameType: if supervisorClient == nil { return utils.LocalGameInputs{}, fmt.Errorf("game type %s requires supervisor rpc to be set", gameType) } diff --git a/op-dispute-mon/mon/extract/caller.go b/op-dispute-mon/mon/extract/caller.go index 366add6e54a..6de5063efc5 100644 --- a/op-dispute-mon/mon/extract/caller.go +++ b/op-dispute-mon/mon/extract/caller.go @@ -60,8 +60,7 @@ func (g *GameCallerCreator) CreateContract(ctx context.Context, game gameTypes.G gameTypes.AsteriscKonaGameType, gameTypes.SuperCannonGameType, gameTypes.SuperPermissionedGameType, - gameTypes.SuperCannonKonaGameType, - gameTypes.SuperAsteriscKonaGameType: + gameTypes.SuperCannonKonaGameType: 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) diff --git a/op-dispute-mon/mon/extract/caller_test.go b/op-dispute-mon/mon/extract/caller_test.go index 119223a5431..32a8e51bd7a 100644 --- a/op-dispute-mon/mon/extract/caller_test.go +++ b/op-dispute-mon/mon/extract/caller_test.go @@ -66,10 +66,6 @@ func TestMetadataCreator_CreateContract(t *testing.T) { name: "validSuperCannonKonaGameType", game: types.GameMetadata{GameType: uint32(types.SuperCannonKonaGameType), Proxy: fdgAddr}, }, - { - name: "validSuperAsteriscKonaGameType", - game: types.GameMetadata{GameType: uint32(types.SuperAsteriscKonaGameType), Proxy: fdgAddr}, - }, { name: "InvalidGameType", game: types.GameMetadata{GameType: 6, Proxy: fdgAddr}, @@ -102,8 +98,7 @@ func setupMetadataLoaderTest(t *testing.T, gameType uint32) (*batching.MultiCall fdgAbi := snapshots.LoadFaultDisputeGameABI() if gameType == uint32(types.SuperPermissionedGameType) || gameType == uint32(types.SuperCannonGameType) || - gameType == uint32(types.SuperCannonKonaGameType) || - gameType == uint32(types.SuperAsteriscKonaGameType) { + gameType == uint32(types.SuperCannonKonaGameType) { fdgAbi = snapshots.LoadSuperFaultDisputeGameABI() } stubRpc := batchingTest.NewAbiBasedRpc(t, fdgAddr, fdgAbi) diff --git a/op-dispute-mon/mon/types/types.go b/op-dispute-mon/mon/types/types.go index 7b1874516c8..753e2291767 100644 --- a/op-dispute-mon/mon/types/types.go +++ b/op-dispute-mon/mon/types/types.go @@ -29,7 +29,6 @@ var outputRootGameTypes = []types.GameType{ var superRootGameTypes = []types.GameType{ types.SuperCannonGameType, types.SuperPermissionedGameType, - types.SuperAsteriscKonaGameType, types.SuperCannonKonaGameType, } From 1d63eb8219cf78f1156800137d88622842aef42a Mon Sep 17 00:00:00 2001 From: Adrian Sutton Date: Mon, 22 Dec 2025 14:13:15 +1000 Subject: [PATCH 2/4] op-challenger: Remove support for asterisc and asterisc-kona game types. --- op-challenger/README.md | 4 +- op-challenger/cmd/main_test.go | 314 +---------------- op-challenger/cmd/run_trace.go | 2 +- op-challenger/cmd/run_trace_test.go | 2 +- op-challenger/config/config.go | 101 +----- op-challenger/config/config_test.go | 333 +----------------- op-challenger/flags/flags.go | 175 +-------- op-challenger/game/fault/contracts/detect.go | 2 - .../game/fault/contracts/disputegame.go | 4 +- op-challenger/game/fault/register.go | 14 - op-challenger/game/fault/register_task.go | 69 ---- .../game/fault/trace/asterisc/provider.go | 198 ----------- .../fault/trace/asterisc/provider_test.go | 278 --------------- .../fault/trace/asterisc/state_converter.go | 70 ---- .../trace/asterisc/state_converter_test.go | 79 ----- .../trace/asterisc/test_data/invalid.json | 3 - .../trace/asterisc/test_data/proofs/0.json | 7 - .../trace/asterisc/test_data/proofs/1.json | 2 - .../trace/asterisc/test_data/proofs/2.json | 9 - .../fault/trace/asterisc/test_data/state.json | 7 - .../fault/trace/outputs/output_asterisc.go | 52 --- .../game/fault/trace/vm/executor_test.go | 2 +- op-challenger/game/types/game_type.go | 14 +- op-challenger/runner/factory.go | 19 - op-dispute-mon/mon/extract/caller.go | 2 - op-dispute-mon/mon/extract/caller_test.go | 8 - op-dispute-mon/mon/types/types.go | 2 - 27 files changed, 36 insertions(+), 1736 deletions(-) delete mode 100644 op-challenger/game/fault/trace/asterisc/provider.go delete mode 100644 op-challenger/game/fault/trace/asterisc/provider_test.go delete mode 100644 op-challenger/game/fault/trace/asterisc/state_converter.go delete mode 100644 op-challenger/game/fault/trace/asterisc/state_converter_test.go delete mode 100644 op-challenger/game/fault/trace/asterisc/test_data/invalid.json delete mode 100644 op-challenger/game/fault/trace/asterisc/test_data/proofs/0.json delete mode 100644 op-challenger/game/fault/trace/asterisc/test_data/proofs/1.json delete mode 100644 op-challenger/game/fault/trace/asterisc/test_data/proofs/2.json delete mode 100644 op-challenger/game/fault/trace/asterisc/test_data/state.json delete mode 100644 op-challenger/game/fault/trace/outputs/output_asterisc.go diff --git a/op-challenger/README.md b/op-challenger/README.md index d217402479b..cc6af5a908e 100644 --- a/op-challenger/README.md +++ b/op-challenger/README.md @@ -218,7 +218,7 @@ Prints the list of current claims in a dispute game. * `ROLLUP_RPC` - the RPC endpoint of the L2 consensus client to use * `DATA_DIR` - the directory to use to store data * `PRESTATES_URL` - the base URL to download required prestates from -* `RUN_CONFIG` - the trace providers and prestates to run. e.g. `cannon,asterisc-kona/kona-0.1.0-alpha.5/0x03c50fbef46a05f93ea7665fa89015c2108e10c1b4501799c0663774bd35a9c5` +* `RUN_CONFIG` - the trace providers and prestates to run. e.g. `cannon,cannon-kona/kona-0.1.0-alpha.5/0x03c50fbef46a05f93ea7665fa89015c2108e10c1b4501799c0663774bd35a9c5` Testing utility that continuously runs the specified trace providers against real chain data. The trace providers can be configured with multiple different prestates. This allows testing both the current and potential future prestates with @@ -226,7 +226,7 @@ the fault proofs virtual machine used by the trace provider. The same CLI options as `op-challenger` itself are supported to configure the trace providers. The additional `--run` option allows specifying which prestates to use. The format is `gameType/name/prestateHash` where gameType is the -game type to use with the prestate (e.g cannon or asterisc-kona), name is an arbitrary name for the prestate to use +game type to use with the prestate (e.g cannon or cannon-kona), name is an arbitrary name for the prestate to use when reporting metrics and prestateHash is the hex encoded absolute prestate commitment to use. If name is omitted the game type name is used. If the prestateHash is omitted, the absolute prestate hash used for new games on-chain is used. diff --git a/op-challenger/cmd/main_test.go b/op-challenger/cmd/main_test.go index 100e1aa70fb..27752f545bf 100644 --- a/op-challenger/cmd/main_test.go +++ b/op-challenger/cmd/main_test.go @@ -34,9 +34,6 @@ var ( cannonKonaPreState = "./cannon-kona-pre.json" datadir = "./test_data" rollupRpc = "http://example.com:8555" - asteriscBin = "./bin/asterisc" - asteriscServer = "./bin/op-program" - asteriscPreState = "./pre.json" ) func TestLogLevel(t *testing.T) { @@ -171,8 +168,8 @@ func TestGameTypes(t *testing.T) { func TestMultipleGameTypes(t *testing.T) { t.Run("WithAllOptions", func(t *testing.T) { argsMap := requiredArgs(gameTypes.CannonGameType) - // Add Asterisc required flags - addRequiredAsteriscArgs(argsMap) + // Add cannon-kona required flags + addRequiredCannonKonaArgs(argsMap) args := toArgList(argsMap) // Add extra game types (cannon is already specified) args = append(args, @@ -180,9 +177,9 @@ func TestMultipleGameTypes(t *testing.T) { args = append(args, "--game-types", gameTypes.PermissionedGameType.String()) args = append(args, - "--game-types", gameTypes.AsteriscGameType.String()) + "--game-types", gameTypes.CannonKonaGameType.String()) cfg := configForArgs(t, args) - require.Equal(t, []gameTypes.GameType{gameTypes.CannonGameType, gameTypes.AlphabetGameType, gameTypes.PermissionedGameType, gameTypes.AsteriscGameType}, cfg.GameTypes) + require.Equal(t, []gameTypes.GameType{gameTypes.CannonGameType, gameTypes.AlphabetGameType, gameTypes.PermissionedGameType, gameTypes.CannonKonaGameType}, cfg.GameTypes) }) t.Run("WithSomeOptions", func(t *testing.T) { argsMap := requiredArgs(gameTypes.CannonGameType) @@ -358,160 +355,6 @@ func TestMinUpdateInterval(t *testing.T) { }) } -func TestAsteriscOpProgramRequiredArgs(t *testing.T) { - gameType := gameTypes.AsteriscGameType - t.Run(fmt.Sprintf("TestAsteriscServer-%v", gameType), func(t *testing.T) { - t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) { - configForArgs(t, addRequiredArgsExcept(gameTypes.AlphabetGameType, "--asterisc-server")) - }) - - t.Run("Required", func(t *testing.T) { - verifyArgsInvalid(t, "flag asterisc-server is required", addRequiredArgsExcept(gameType, "--asterisc-server")) - }) - - t.Run("Valid", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgsExcept(gameType, "--asterisc-server", "--asterisc-server=./op-program")) - require.Equal(t, "./op-program", cfg.Asterisc.Server) - }) - }) - - t.Run(fmt.Sprintf("TestAsteriscAbsolutePrestate-%v", gameType), func(t *testing.T) { - t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) { - configForArgs(t, addRequiredArgsExcept(gameTypes.AlphabetGameType, "--asterisc-prestate")) - }) - - t.Run("Required", func(t *testing.T) { - verifyArgsInvalid(t, "flag prestates-url/asterisc-prestates-url or asterisc-prestate is required", addRequiredArgsExcept(gameType, "--asterisc-prestate")) - }) - - t.Run("Valid", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgsExcept(gameType, "--asterisc-prestate", "--asterisc-prestate=./pre.json")) - require.Equal(t, "./pre.json", cfg.AsteriscAbsolutePreState) - }) - }) - - t.Run(fmt.Sprintf("TestPrestateBaseURL-%v", gameType), func(t *testing.T) { - allPrestateOptions := []string{"--prestates-url", "--asterisc-prestates-url", "--asterisc-prestate"} - t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) { - configForArgs(t, addRequiredArgsExceptArr(gameTypes.AlphabetGameType, allPrestateOptions)) - }) - - t.Run("NotRequiredIfAsteriscPrestatesBaseURLSet", func(t *testing.T) { - configForArgs(t, addRequiredArgsExceptArr(gameType, allPrestateOptions, "--asterisc-prestates-url=http://localhost/foo")) - }) - - t.Run("AsteriscPrestatesBaseURLTakesPrecedence", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgsExceptArr(gameType, allPrestateOptions, "--asterisc-prestates-url=http://localhost/foo", "--prestates-url=http://localhost/bar")) - require.Equal(t, "http://localhost/foo", cfg.AsteriscAbsolutePreStateBaseURL.String()) - }) - - t.Run("RequiredIfAsteriscPrestatesBaseURLNotSet", func(t *testing.T) { - verifyArgsInvalid(t, "flag prestates-url/asterisc-prestates-url or asterisc-prestate is required", addRequiredArgsExceptArr(gameType, allPrestateOptions)) - }) - - t.Run("Invalid", func(t *testing.T) { - verifyArgsInvalid(t, "invalid prestates-url (:foo/bar)", addRequiredArgsExceptArr(gameType, allPrestateOptions, "--prestates-url=:foo/bar")) - }) - - t.Run("Valid", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgsExceptArr(gameType, allPrestateOptions, "--prestates-url=http://localhost/foo")) - require.Equal(t, "http://localhost/foo", cfg.AsteriscAbsolutePreStateBaseURL.String()) - }) - }) - - t.Run(fmt.Sprintf("TestAsteriscAbsolutePrestateBaseURL-%v", gameType), func(t *testing.T) { - t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) { - configForArgs(t, addRequiredArgsExcept(gameTypes.AlphabetGameType, "--asterisc-prestates-url")) - }) - - t.Run("Required", func(t *testing.T) { - verifyArgsInvalid(t, "flag prestates-url/asterisc-prestates-url or asterisc-prestate is required", addRequiredArgsExcept(gameType, "--asterisc-prestate")) - }) - - t.Run("Valid", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgsExcept(gameType, "--asterisc-prestates-url", "--asterisc-prestates-url=http://localhost/bar")) - require.Equal(t, "http://localhost/bar", cfg.AsteriscAbsolutePreStateBaseURL.String()) - }) - }) -} - -func TestAsteriscKonaRequiredArgs(t *testing.T) { - gameType := gameTypes.AsteriscKonaGameType - t.Run(fmt.Sprintf("TestAsteriscServer-%v", gameType), func(t *testing.T) { - t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) { - configForArgs(t, addRequiredArgsExcept(gameTypes.AlphabetGameType, "--asterisc-kona-server")) - }) - - t.Run("Required", func(t *testing.T) { - verifyArgsInvalid(t, "flag asterisc-kona-server is required", addRequiredArgsExcept(gameType, "--asterisc-kona-server")) - }) - - t.Run("Valid", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgsExcept(gameType, "--asterisc-kona-server", "--asterisc-kona-server=./kona-host")) - require.Equal(t, "./kona-host", cfg.AsteriscKona.Server) - }) - }) - - t.Run(fmt.Sprintf("TestAsteriscAbsolutePrestate-%v", gameType), func(t *testing.T) { - t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) { - configForArgs(t, addRequiredArgsExcept(gameTypes.AlphabetGameType, "--asterisc-kona-prestate")) - }) - - t.Run("Required", func(t *testing.T) { - verifyArgsInvalid(t, "flag prestates-url/asterisc-kona-prestates-url or asterisc-kona-prestate is required", addRequiredArgsExcept(gameType, "--asterisc-kona-prestate")) - }) - - t.Run("Valid", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgsExcept(gameType, "--asterisc-kona-prestate", "--asterisc-kona-prestate=./pre.json")) - require.Equal(t, "./pre.json", cfg.AsteriscKonaAbsolutePreState) - }) - }) - - t.Run(fmt.Sprintf("TestAsteriscAbsolutePrestateBaseURL-%v", gameType), func(t *testing.T) { - t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) { - configForArgs(t, addRequiredArgsExcept(gameTypes.AlphabetGameType, "--asterisc-kona-prestates-url")) - }) - - t.Run("Required", func(t *testing.T) { - verifyArgsInvalid(t, "flag prestates-url/asterisc-kona-prestates-url or asterisc-kona-prestate is required", addRequiredArgsExcept(gameType, "--asterisc-kona-prestate")) - }) - - t.Run("Valid", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgsExcept(gameType, "--asterisc-kona-prestates-url", "--asterisc-kona-prestates-url=http://localhost/bar")) - require.Equal(t, "http://localhost/bar", cfg.AsteriscKonaAbsolutePreStateBaseURL.String()) - }) - }) - - t.Run(fmt.Sprintf("TestPrestateBaseURL-%v", gameType), func(t *testing.T) { - allPrestateOptions := []string{"--prestates-url", "--asterisc-kona-prestates-url", "--asterisc-kona-prestate"} - t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) { - configForArgs(t, addRequiredArgsExceptArr(gameTypes.AlphabetGameType, allPrestateOptions)) - }) - - t.Run("NotRequiredIfAsteriscKonaPrestatesBaseURLSet", func(t *testing.T) { - configForArgs(t, addRequiredArgsExceptArr(gameType, allPrestateOptions, "--asterisc-kona-prestates-url=http://localhost/foo")) - }) - - t.Run("AsteriscKonaPrestatesBaseURLTakesPrecedence", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgsExceptArr(gameType, allPrestateOptions, "--asterisc-kona-prestates-url=http://localhost/foo", "--prestates-url=http://localhost/bar")) - require.Equal(t, "http://localhost/foo", cfg.AsteriscKonaAbsolutePreStateBaseURL.String()) - }) - - t.Run("RequiredIfAsteriscKonaPrestatesBaseURLNotSet", func(t *testing.T) { - verifyArgsInvalid(t, "flag prestates-url/asterisc-kona-prestates-url or asterisc-kona-prestate is required", addRequiredArgsExceptArr(gameType, allPrestateOptions)) - }) - - t.Run("Invalid", func(t *testing.T) { - verifyArgsInvalid(t, "invalid prestates-url (:foo/bar)", addRequiredArgsExceptArr(gameType, allPrestateOptions, "--prestates-url=:foo/bar")) - }) - - t.Run("Valid", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgsExceptArr(gameType, allPrestateOptions, "--prestates-url=http://localhost/foo")) - require.Equal(t, "http://localhost/foo", cfg.AsteriscKonaAbsolutePreStateBaseURL.String()) - }) - }) -} - // validateCustomNetworkFlagsProhibitedWithNetworkFlag ensures custom network flags are not used simultaneously with the network flag. // It validates disallowed flag combinations for a given game type and game type prefix configuration. func validateCustomNetworkFlagsProhibitedWithNetworkFlag(t *testing.T, gameType gameTypes.GameType, gameTypeForFlagPrefix gameTypes.GameType, customNetworkFlag string) { @@ -554,135 +397,6 @@ func validateCustomNetworkFlagsProhibitedWithNetworkFlag(t *testing.T, gameType } } -func TestAsteriscBaseRequiredArgs(t *testing.T) { - for _, gameType := range []gameTypes.GameType{gameTypes.AsteriscGameType, gameTypes.AsteriscKonaGameType} { - gameType := gameType - t.Run(fmt.Sprintf("TestAsteriscBin-%v", gameType), func(t *testing.T) { - t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) { - configForArgs(t, addRequiredArgsExcept(gameTypes.AlphabetGameType, "--asterisc-bin")) - }) - - t.Run("Required", func(t *testing.T) { - verifyArgsInvalid(t, "flag asterisc-bin is required", addRequiredArgsExcept(gameType, "--asterisc-bin")) - }) - - t.Run("Valid", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgsExcept(gameType, "--asterisc-bin", "--asterisc-bin=./asterisc")) - require.Equal(t, "./asterisc", cfg.Asterisc.VmBin) - }) - }) - - t.Run(fmt.Sprintf("TestL2Rpc-%v", gameType), func(t *testing.T) { - t.Run("RequiredForAsteriscTrace", func(t *testing.T) { - verifyArgsInvalid(t, "flag l2-eth-rpc is required", addRequiredArgsExcept(gameType, "--l2-eth-rpc")) - }) - - t.Run("Valid", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgs(gameType)) - require.Equal(t, []string{l2EthRpc}, cfg.L2Rpcs) - }) - }) - - t.Run(fmt.Sprintf("TestAsteriscSnapshotFreq-%v", gameType), func(t *testing.T) { - t.Run("UsesDefault", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgs(gameType)) - require.Equal(t, config.DefaultAsteriscSnapshotFreq, cfg.Asterisc.SnapshotFreq) - }) - - t.Run("Valid", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgs(gameType, "--asterisc-snapshot-freq=1234")) - require.Equal(t, uint(1234), cfg.Asterisc.SnapshotFreq) - }) - - t.Run("Invalid", func(t *testing.T) { - verifyArgsInvalid(t, "invalid value \"abc\" for flag -asterisc-snapshot-freq", - addRequiredArgs(gameType, "--asterisc-snapshot-freq=abc")) - }) - }) - - t.Run(fmt.Sprintf("TestAsteriscInfoFreq-%v", gameType), func(t *testing.T) { - t.Run("UsesDefault", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgs(gameType)) - require.Equal(t, config.DefaultAsteriscInfoFreq, cfg.Asterisc.InfoFreq) - }) - - t.Run("Valid", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgs(gameType, "--asterisc-info-freq=1234")) - require.Equal(t, uint(1234), cfg.Asterisc.InfoFreq) - }) - - t.Run("Invalid", func(t *testing.T) { - verifyArgsInvalid(t, "invalid value \"abc\" for flag -asterisc-info-freq", - addRequiredArgs(gameType, "--asterisc-info-freq=abc")) - }) - }) - - t.Run(fmt.Sprintf("TestRequireEitherNetworkOrRollupAndGenesis-%v", gameType), func(t *testing.T) { - verifyArgsInvalid( - t, - fmt.Sprintf("flag network or rollup-config/%s-rollup-config and l2-genesis/%s-l2-genesis is required", gameType, gameType), - addRequiredArgsExcept(gameType, "--network")) - verifyArgsInvalid( - t, - fmt.Sprintf("flag network or rollup-config/%s-rollup-config and l2-genesis/%s-l2-genesis is required", gameType, gameType), - addRequiredArgsExcept(gameType, "--network", "--rollup-config=rollup.json")) - verifyArgsInvalid( - t, - fmt.Sprintf("flag network or rollup-config/%s-rollup-config and l2-genesis/%s-l2-genesis is required", gameType, gameType), - addRequiredArgsExcept(gameType, "--network", "--l2-genesis=gensis.json")) - }) - - validateCustomNetworkFlagsProhibitedWithNetworkFlag(t, gameType, gameTypes.AsteriscKonaGameType, "asterisc-kona-l2-custom") - - t.Run(fmt.Sprintf("TestNetwork-%v", gameType), func(t *testing.T) { - t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) { - configForArgs(t, addRequiredArgsExcept(gameTypes.AlphabetGameType, "--network")) - }) - - t.Run("NotRequiredWhenRollupAndGenesisSpecified", func(t *testing.T) { - configForArgs(t, addRequiredArgsExcept(gameType, "--network", - "--rollup-config=rollup.json", "--l2-genesis=genesis.json")) - }) - - t.Run("NotRequiredWhenNetworkSpecified", func(t *testing.T) { - args := requiredArgs(gameType) - delete(args, "--network") - delete(args, "--game-factory-address") - args["--network"] = "op-sepolia" - cfg := configForArgs(t, toArgList(args)) - require.Equal(t, []string{"op-sepolia"}, cfg.Asterisc.Networks) - }) - - t.Run("Valid", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgsExcept(gameType, "--network", "--network", testNetwork)) - require.Equal(t, []string{testNetwork}, cfg.Asterisc.Networks) - }) - }) - - t.Run(fmt.Sprintf("TestAsteriscRollupConfig-%v", gameType), func(t *testing.T) { - t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) { - configForArgs(t, addRequiredArgsExcept(gameTypes.AlphabetGameType, "--asterisc-rollup-config")) - }) - - t.Run("Valid", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgsExcept(gameType, "--network", "--rollup-config=rollup.json", "--l2-genesis=genesis.json")) - require.Equal(t, []string{"rollup.json"}, cfg.Asterisc.RollupConfigPaths) - }) - }) - - t.Run(fmt.Sprintf("TestL2Genesis-%v", gameType), func(t *testing.T) { - t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) { - configForArgs(t, addRequiredArgsExcept(gameTypes.AlphabetGameType, "--l2-genesis")) - }) - - t.Run("Valid", func(t *testing.T) { - cfg := configForArgs(t, addRequiredArgsExcept(gameType, "--network", "--rollup-config=rollup.json", "--l2-genesis=genesis.json")) - require.Equal(t, []string{"genesis.json"}, cfg.Asterisc.L2GenesisPaths) - }) - }) - } -} - func TestAlphabetRequiredArgs(t *testing.T) { t.Run(fmt.Sprintf("TestL2Rpc-%v", gameTypes.AlphabetGameType), func(t *testing.T) { t.Run("RequiredForAlphabetTrace", func(t *testing.T) { @@ -1297,10 +1011,6 @@ func requiredArgs(gameType gameTypes.GameType) map[string]string { addRequiredCannonArgs(args) case gameTypes.CannonKonaGameType: addRequiredCannonKonaArgs(args) - case gameTypes.AsteriscGameType: - addRequiredAsteriscArgs(args) - case gameTypes.AsteriscKonaGameType: - addRequiredAsteriscKonaArgs(args) case gameTypes.SuperCannonGameType, gameTypes.SuperPermissionedGameType: addRequiredSuperCannonArgs(args) case gameTypes.SuperCannonKonaGameType: @@ -1349,22 +1059,6 @@ func addRequiredSuperCannonKonaArgs(args map[string]string) { args["--supervisor-rpc"] = supervisorRpc } -func addRequiredAsteriscArgs(args map[string]string) { - addRequiredOutputRootArgs(args) - args["--network"] = network - args["--asterisc-bin"] = asteriscBin - args["--asterisc-server"] = asteriscServer - args["--asterisc-prestate"] = asteriscPreState -} - -func addRequiredAsteriscKonaArgs(args map[string]string) { - addRequiredOutputRootArgs(args) - args["--network"] = network - args["--asterisc-bin"] = asteriscBin - args["--asterisc-kona-server"] = asteriscServer - args["--asterisc-kona-prestate"] = asteriscPreState -} - func toArgList(req map[string]string) []string { var combined []string for name, value := range req { diff --git a/op-challenger/cmd/run_trace.go b/op-challenger/cmd/run_trace.go index e2fee2e800f..baa1a5328d0 100644 --- a/op-challenger/cmd/run_trace.go +++ b/op-challenger/cmd/run_trace.go @@ -62,7 +62,7 @@ var ( RunTraceRunFlag = &cli.StringSliceFlag{ Name: "run", Usage: "Specify a trace to run. Format is gameType/name/prestateHash where " + - "gameType is the game type to use with the prestate (e.g cannon or asterisc-kona), " + + "gameType is the game type to use with the prestate (e.g cannon or cannon-kona), " + "name is an arbitrary name for the prestate to use when reporting metrics and" + "prestateHash is the hex encoded absolute prestate commitment to use. " + "If name is omitted the game type name is used." + diff --git a/op-challenger/cmd/run_trace_test.go b/op-challenger/cmd/run_trace_test.go index a2b5b664446..bff4d0c6651 100644 --- a/op-challenger/cmd/run_trace_test.go +++ b/op-challenger/cmd/run_trace_test.go @@ -18,7 +18,7 @@ func TestParseRunArg(t *testing.T) { }{ {arg: "unknown/test1/0x1234", err: gameTypes.ErrUnknownGameType}, {arg: "cannon", expected: runner.RunConfig{GameType: gameTypes.CannonGameType, Name: gameTypes.CannonGameType.String()}}, - {arg: "asterisc", expected: runner.RunConfig{GameType: gameTypes.AsteriscGameType, Name: gameTypes.AsteriscGameType.String()}}, + {arg: "cannon-kona", expected: runner.RunConfig{GameType: gameTypes.CannonKonaGameType, Name: gameTypes.CannonKonaGameType.String()}}, {arg: "cannon/test1", expected: runner.RunConfig{GameType: gameTypes.CannonGameType, Name: "test1"}}, {arg: "cannon/test1/0x1234", expected: runner.RunConfig{GameType: gameTypes.CannonGameType, Name: "test1", Prestate: common.HexToHash("0x1234")}}, {arg: "cannon/test1/0xinvalid", err: ErrInvalidPrestateHash}, diff --git a/op-challenger/config/config.go b/op-challenger/config/config.go index a62863284e6..98875012e58 100644 --- a/op-challenger/config/config.go +++ b/op-challenger/config/config.go @@ -34,22 +34,12 @@ var ( ErrMissingRollupRpc = errors.New("missing rollup rpc url") ErrMissingSupervisorRpc = errors.New("missing supervisor rpc url") - - ErrMissingAsteriscAbsolutePreState = errors.New("missing asterisc absolute pre-state") - ErrMissingAsteriscSnapshotFreq = errors.New("missing asterisc snapshot freq") - ErrMissingAsteriscInfoFreq = errors.New("missing asterisc info freq") - - ErrMissingAsteriscKonaAbsolutePreState = errors.New("missing asterisc kona absolute pre-state") - ErrMissingAsteriscKonaSnapshotFreq = errors.New("missing asterisc kona snapshot freq") - ErrMissingAsteriscKonaInfoFreq = errors.New("missing asterisc kona info freq") ) const ( - DefaultPollInterval = time.Second * 12 - DefaultCannonSnapshotFreq = uint(1_000_000_000) - DefaultCannonInfoFreq = uint(10_000_000) - DefaultAsteriscSnapshotFreq = uint(1_000_000_000) - DefaultAsteriscInfoFreq = uint(10_000_000) + DefaultPollInterval = time.Second * 12 + DefaultCannonSnapshotFreq = uint(1_000_000_000) + DefaultCannonInfoFreq = uint(10_000_000) // DefaultGameWindow is the default maximum time duration in the past // that the challenger will look for games to progress. // The default value is 28 days. The worst case duration for a game is 16 days @@ -94,14 +84,6 @@ type Config struct { CannonKonaAbsolutePreState string // File to load the absolute pre-state for CannonKona traces from CannonKonaAbsolutePreStateBaseURL *url.URL // Base URL to retrieve absolute pre-states for CannonKona 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 - 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) TxMgrConfig txmgr.CLIConfig @@ -170,24 +152,6 @@ func NewInteropConfig( DebugInfo: true, BinarySnapshots: true, }, - Asterisc: vm.Config{ - VmType: gameTypes.AsteriscGameType, - L1: l1EthRpc, - L1Beacon: l1BeaconApi, - L2s: l2Rpcs, - SnapshotFreq: DefaultAsteriscSnapshotFreq, - InfoFreq: DefaultAsteriscInfoFreq, - BinarySnapshots: true, - }, - AsteriscKona: vm.Config{ - VmType: gameTypes.AsteriscKonaGameType, - L1: l1EthRpc, - L1Beacon: l1BeaconApi, - L2s: l2Rpcs, - SnapshotFreq: DefaultAsteriscSnapshotFreq, - InfoFreq: DefaultAsteriscInfoFreq, - BinarySnapshots: true, - }, GameWindow: DefaultGameWindow, } } @@ -240,24 +204,6 @@ func NewConfig( DebugInfo: true, BinarySnapshots: true, }, - Asterisc: vm.Config{ - VmType: gameTypes.AsteriscGameType, - L1: l1EthRpc, - L1Beacon: l1BeaconApi, - L2s: []string{l2EthRpc}, - SnapshotFreq: DefaultAsteriscSnapshotFreq, - InfoFreq: DefaultAsteriscInfoFreq, - BinarySnapshots: true, - }, - AsteriscKona: vm.Config{ - VmType: gameTypes.AsteriscKonaGameType, - L1: l1EthRpc, - L1Beacon: l1BeaconApi, - L2s: []string{l2EthRpc}, - SnapshotFreq: DefaultAsteriscSnapshotFreq, - InfoFreq: DefaultAsteriscInfoFreq, - BinarySnapshots: true, - }, GameWindow: DefaultGameWindow, } } @@ -328,31 +274,6 @@ func (c Config) Check() error { return err } } - if c.GameTypeEnabled(gameTypes.AsteriscGameType) { - if c.RollupRpc == "" { - return ErrMissingRollupRpc - } - if err := c.Asterisc.Check(); err != nil { - return fmt.Errorf("asterisc: %w", err) - } - if c.AsteriscAbsolutePreState == "" && c.AsteriscAbsolutePreStateBaseURL == nil { - return ErrMissingAsteriscAbsolutePreState - } - if c.Asterisc.SnapshotFreq == 0 { - return ErrMissingAsteriscSnapshotFreq - } - if c.Asterisc.InfoFreq == 0 { - return ErrMissingAsteriscInfoFreq - } - } - if c.GameTypeEnabled(gameTypes.AsteriscKonaGameType) { - if c.RollupRpc == "" { - return ErrMissingRollupRpc - } - if err := c.validateBaseAsteriscKonaOptions(); err != nil { - return err - } - } if c.GameTypeEnabled(gameTypes.OptimisticZKGameType) { if c.RollupRpc == "" { return ErrMissingRollupRpc @@ -406,19 +327,3 @@ func (c Config) validateBaseCannonKonaOptions() error { } return nil } - -func (c Config) validateBaseAsteriscKonaOptions() error { - if err := c.AsteriscKona.Check(); err != nil { - return fmt.Errorf("asterisc kona: %w", err) - } - if c.AsteriscKonaAbsolutePreState == "" && c.AsteriscKonaAbsolutePreStateBaseURL == nil { - return ErrMissingAsteriscKonaAbsolutePreState - } - if c.AsteriscKona.SnapshotFreq == 0 { - return ErrMissingAsteriscKonaSnapshotFreq - } - if c.AsteriscKona.InfoFreq == 0 { - return ErrMissingAsteriscKonaInfoFreq - } - return nil -} diff --git a/op-challenger/config/config_test.go b/op-challenger/config/config_test.go index c73348c766d..0791dbf8d5f 100644 --- a/op-challenger/config/config_test.go +++ b/op-challenger/config/config_test.go @@ -31,18 +31,7 @@ var ( validRollupRpc = "http://localhost:8555" validSupervisorRpc = "http://localhost/supervisor" - validAsteriscBin = "./bin/asterisc" - validAsteriscOpProgramBin = "./bin/op-program" - validAsteriscNetwork = "mainnet" - validAsteriscAbsolutePreState = "pre.json" - validAsteriscAbsolutePreStateBaseURL, _ = url.Parse("http://localhost/bar/") - - nonExistingFile = "path/to/nonexistent/file" - validAsteriscKonaBin = "./bin/asterisc" - validAsteriscKonaServerBin = "./bin/kona-host" - validAsteriscKonaNetwork = "mainnet" - validAsteriscKonaAbsolutePreState = "pre.json" - validAsteriscKonaAbsolutePreStateBaseURL, _ = url.Parse("http://localhost/bar/") + nonExistingFile = "path/to/nonexistent/file" validCannonKonaBin = "./bin/cannon" validCannonKonaServerBin = "./bin/kona-host" @@ -54,8 +43,6 @@ var singleCannonGameTypes = []gameTypes.GameType{gameTypes.CannonGameType, gameT var superCannonGameTypes = []gameTypes.GameType{gameTypes.SuperCannonGameType, gameTypes.SuperPermissionedGameType} var allCannonGameTypes []gameTypes.GameType var cannonKonaGameTypes = []gameTypes.GameType{gameTypes.CannonKonaGameType, gameTypes.SuperCannonKonaGameType} -var asteriscGameTypes = []gameTypes.GameType{gameTypes.AsteriscGameType} -var asteriscKonaGameTypes = []gameTypes.GameType{gameTypes.AsteriscKonaGameType} func init() { allCannonGameTypes = append(allCannonGameTypes, singleCannonGameTypes...) @@ -97,34 +84,6 @@ func applyValidConfigForCannon(t *testing.T, cfg *Config) { cfg.Cannon.Networks = []string{validCannonNetwork} } -func applyValidConfigForAsterisc(t *testing.T, cfg *Config) { - tmpDir := t.TempDir() - vmBin := filepath.Join(tmpDir, validAsteriscBin) - server := filepath.Join(tmpDir, validAsteriscOpProgramBin) - err := ensureExists(vmBin) - require.NoError(t, err) - err = ensureExists(server) - require.NoError(t, err) - cfg.Asterisc.VmBin = vmBin - cfg.Asterisc.Server = server - cfg.AsteriscAbsolutePreStateBaseURL = validAsteriscAbsolutePreStateBaseURL - cfg.Asterisc.Networks = []string{validAsteriscNetwork} -} - -func applyValidConfigForAsteriscKona(t *testing.T, cfg *Config) { - tmpDir := t.TempDir() - vmBin := filepath.Join(tmpDir, validAsteriscKonaBin) - server := filepath.Join(tmpDir, validAsteriscKonaServerBin) - err := ensureExists(vmBin) - require.NoError(t, err) - err = ensureExists(server) - require.NoError(t, err) - cfg.AsteriscKona.VmBin = vmBin - cfg.AsteriscKona.Server = server - cfg.AsteriscKonaAbsolutePreStateBaseURL = validAsteriscKonaAbsolutePreStateBaseURL - cfg.AsteriscKona.Networks = []string{validAsteriscKonaNetwork} -} - func applyValidConfigForCannonKona(t *testing.T, cfg *Config) { tmpDir := t.TempDir() vmBin := filepath.Join(tmpDir, validCannonKonaBin) @@ -162,12 +121,6 @@ func validConfig(t *testing.T, gameType gameTypes.GameType) Config { if gameType == gameTypes.SuperCannonKonaGameType { applyValidConfigForSuperCannonKona(t, &cfg) } - if gameType == gameTypes.AsteriscGameType { - applyValidConfigForAsterisc(t, &cfg) - } - if gameType == gameTypes.AsteriscKonaGameType { - applyValidConfigForAsteriscKona(t, &cfg) - } if gameType == gameTypes.OptimisticZKGameType { applyValidConfigForOptimisticZK(&cfg) } @@ -190,12 +143,6 @@ func validConfigWithNoNetworks(t *testing.T, gameType gameTypes.GameType) Config if slices.Contains(cannonKonaGameTypes, gameType) { mutateVmConfig(&cfg.CannonKona) } - if slices.Contains(asteriscGameTypes, gameType) { - mutateVmConfig(&cfg.Asterisc) - } - if slices.Contains(asteriscKonaGameTypes, gameType) { - mutateVmConfig(&cfg.AsteriscKona) - } return cfg } @@ -521,243 +468,6 @@ func TestDepsetConfig(t *testing.T) { require.NoError(t, cfg.Check()) }) } - - for _, gameType := range asteriscKonaGameTypes { - gameType := gameType - t.Run(fmt.Sprintf("TestDepsetConfigNotRequired-%v", gameType), func(t *testing.T) { - cfg := validConfig(t, gameType) - cfg.AsteriscKona.Networks = nil - cfg.AsteriscKona.RollupConfigPaths = []string{"foo.json"} - cfg.AsteriscKona.L1GenesisPath = "bar.json" - cfg.AsteriscKona.L2GenesisPaths = []string{"genesis.json"} - cfg.AsteriscKona.DepsetConfigPath = "" - require.NoError(t, cfg.Check()) - }) - } -} - -func TestAsteriscRequiredArgs(t *testing.T) { - for _, gameType := range asteriscGameTypes { - gameType := gameType - - t.Run(fmt.Sprintf("TestAsteriscBinRequired-%v", gameType), func(t *testing.T) { - config := validConfig(t, gameType) - config.Asterisc.VmBin = "" - require.ErrorIs(t, config.Check(), vm.ErrMissingBin) - }) - - t.Run(fmt.Sprintf("TestAsteriscServerRequired-%v", gameType), func(t *testing.T) { - config := validConfig(t, gameType) - config.Asterisc.Server = "" - require.ErrorIs(t, config.Check(), vm.ErrMissingServer) - }) - - t.Run(fmt.Sprintf("TestAsteriscAbsolutePreStateOrBaseURLRequired-%v", gameType), func(t *testing.T) { - config := validConfig(t, gameType) - config.AsteriscAbsolutePreState = "" - config.AsteriscAbsolutePreStateBaseURL = nil - require.ErrorIs(t, config.Check(), ErrMissingAsteriscAbsolutePreState) - }) - - t.Run(fmt.Sprintf("TestAsteriscAbsolutePreState-%v", gameType), func(t *testing.T) { - config := validConfig(t, gameType) - config.AsteriscAbsolutePreState = validAsteriscAbsolutePreState - config.AsteriscAbsolutePreStateBaseURL = nil - require.NoError(t, config.Check()) - }) - - t.Run(fmt.Sprintf("TestAsteriscAbsolutePreStateBaseURL-%v", gameType), func(t *testing.T) { - config := validConfig(t, gameType) - config.AsteriscAbsolutePreState = "" - config.AsteriscAbsolutePreStateBaseURL = validAsteriscAbsolutePreStateBaseURL - require.NoError(t, config.Check()) - }) - - t.Run(fmt.Sprintf("TestAllowSupplingBothAsteriscAbsolutePreStateAndBaseURL-%v", gameType), func(t *testing.T) { - // Since the prestate base URL might be inherited from the --prestate-urls option, allow overriding it with a specific prestate - config := validConfig(t, gameType) - config.AsteriscAbsolutePreState = validAsteriscAbsolutePreState - config.AsteriscAbsolutePreStateBaseURL = validAsteriscAbsolutePreStateBaseURL - require.NoError(t, config.Check()) - }) - - t.Run(fmt.Sprintf("TestL2RpcRequired-%v", gameType), func(t *testing.T) { - config := validConfig(t, gameType) - config.L2Rpcs = nil - require.ErrorIs(t, config.Check(), ErrMissingL2Rpc) - }) - - t.Run(fmt.Sprintf("TestAsteriscSnapshotFreq-%v", gameType), func(t *testing.T) { - t.Run("MustNotBeZero", func(t *testing.T) { - cfg := validConfig(t, gameType) - cfg.Asterisc.SnapshotFreq = 0 - require.ErrorIs(t, cfg.Check(), ErrMissingAsteriscSnapshotFreq) - }) - }) - - t.Run(fmt.Sprintf("TestAsteriscInfoFreq-%v", gameType), func(t *testing.T) { - t.Run("MustNotBeZero", func(t *testing.T) { - cfg := validConfig(t, gameType) - cfg.Asterisc.InfoFreq = 0 - require.ErrorIs(t, cfg.Check(), ErrMissingAsteriscInfoFreq) - }) - }) - - t.Run(fmt.Sprintf("TestAsteriscNetworkOrRollupConfigRequired-%v", gameType), func(t *testing.T) { - cfg := validConfigWithNoNetworks(t, gameType) - cfg.Asterisc.RollupConfigPaths = nil - require.ErrorIs(t, cfg.Check(), vm.ErrMissingRollupConfig) - }) - - t.Run(fmt.Sprintf("TestAsteriscNetworkOrL2GenesisRequired-%v", gameType), func(t *testing.T) { - cfg := validConfigWithNoNetworks(t, gameType) - cfg.Asterisc.L2GenesisPaths = nil - require.ErrorIs(t, cfg.Check(), vm.ErrMissingL2Genesis) - }) - - t.Run(fmt.Sprintf("MaySpecifyNetworkAndCustomConfigs-%v", gameType), func(t *testing.T) { - cfg := validConfig(t, gameType) - cfg.Asterisc.Networks = []string{validAsteriscNetwork} - cfg.Asterisc.RollupConfigPaths = []string{"foo.json"} - cfg.Asterisc.L2GenesisPaths = []string{"genesis.json"} - require.NoError(t, cfg.Check()) - }) - - t.Run(fmt.Sprintf("TestNetworkMustBeValid-%v", gameType), func(t *testing.T) { - cfg := validConfig(t, gameType) - cfg.Asterisc.Networks = []string{"unknown"} - require.ErrorIs(t, cfg.Check(), vm.ErrNetworkUnknown) - }) - - t.Run(fmt.Sprintf("TestDebugInfoDisabled-%v", gameType), func(t *testing.T) { - cfg := validConfig(t, gameType) - require.False(t, cfg.Asterisc.DebugInfo) - }) - - t.Run(fmt.Sprintf("TestVMBinExists-%v", gameType), func(t *testing.T) { - cfg := validConfig(t, gameType) - cfg.Asterisc.VmBin = nonExistingFile - require.ErrorIs(t, cfg.Check(), vm.ErrMissingBin) - }) - - t.Run(fmt.Sprintf("TestServerExists-%v", gameType), func(t *testing.T) { - cfg := validConfig(t, gameType) - cfg.Asterisc.Server = nonExistingFile - require.ErrorIs(t, cfg.Check(), vm.ErrMissingServer) - }) - } -} - -func TestAsteriscKonaRequiredArgs(t *testing.T) { - for _, gameType := range asteriscKonaGameTypes { - gameType := gameType - - t.Run(fmt.Sprintf("TestAsteriscKonaBinRequired-%v", gameType), func(t *testing.T) { - config := validConfig(t, gameType) - config.AsteriscKona.VmBin = "" - require.ErrorIs(t, config.Check(), vm.ErrMissingBin) - }) - - t.Run(fmt.Sprintf("TestAsteriscKonaServerRequired-%v", gameType), func(t *testing.T) { - config := validConfig(t, gameType) - config.AsteriscKona.Server = "" - require.ErrorIs(t, config.Check(), vm.ErrMissingServer) - }) - - t.Run(fmt.Sprintf("TestAsteriscKonaAbsolutePreStateOrBaseURLRequired-%v", gameType), func(t *testing.T) { - config := validConfig(t, gameType) - config.AsteriscKonaAbsolutePreState = "" - config.AsteriscKonaAbsolutePreStateBaseURL = nil - require.ErrorIs(t, config.Check(), ErrMissingAsteriscKonaAbsolutePreState) - }) - - t.Run(fmt.Sprintf("TestAsteriscKonaAbsolutePreState-%v", gameType), func(t *testing.T) { - config := validConfig(t, gameType) - config.AsteriscKonaAbsolutePreState = validAsteriscKonaAbsolutePreState - config.AsteriscKonaAbsolutePreStateBaseURL = nil - require.NoError(t, config.Check()) - }) - - t.Run(fmt.Sprintf("TestAsteriscKonaAbsolutePreStateBaseURL-%v", gameType), func(t *testing.T) { - config := validConfig(t, gameType) - config.AsteriscKonaAbsolutePreState = "" - config.AsteriscKonaAbsolutePreStateBaseURL = validAsteriscKonaAbsolutePreStateBaseURL - require.NoError(t, config.Check()) - }) - - t.Run(fmt.Sprintf("TestAllowSupplyingBothAsteriscKonaAbsolutePreStateAndBaseURL-%v", gameType), func(t *testing.T) { - // Since the prestate base URL might be inherited from the --prestate-urls option, allow overriding it with a specific prestate - config := validConfig(t, gameType) - config.AsteriscKonaAbsolutePreState = validAsteriscKonaAbsolutePreState - config.AsteriscKonaAbsolutePreStateBaseURL = validAsteriscKonaAbsolutePreStateBaseURL - require.NoError(t, config.Check()) - }) - - t.Run(fmt.Sprintf("TestL2RpcRequired-%v", gameType), func(t *testing.T) { - config := validConfig(t, gameType) - config.L2Rpcs = nil - require.ErrorIs(t, config.Check(), ErrMissingL2Rpc) - }) - - t.Run(fmt.Sprintf("TestAsteriscKonaSnapshotFreq-%v", gameType), func(t *testing.T) { - t.Run("MustNotBeZero", func(t *testing.T) { - cfg := validConfig(t, gameType) - cfg.AsteriscKona.SnapshotFreq = 0 - require.ErrorIs(t, cfg.Check(), ErrMissingAsteriscKonaSnapshotFreq) - }) - }) - - t.Run(fmt.Sprintf("TestAsteriscKonaInfoFreq-%v", gameType), func(t *testing.T) { - t.Run("MustNotBeZero", func(t *testing.T) { - cfg := validConfig(t, gameType) - cfg.AsteriscKona.InfoFreq = 0 - require.ErrorIs(t, cfg.Check(), ErrMissingAsteriscKonaInfoFreq) - }) - }) - - t.Run(fmt.Sprintf("TestAsteriscKonaNetworkOrRollupConfigRequired-%v", gameType), func(t *testing.T) { - cfg := validConfigWithNoNetworks(t, gameType) - cfg.AsteriscKona.RollupConfigPaths = nil - require.ErrorIs(t, cfg.Check(), vm.ErrMissingRollupConfig) - }) - - t.Run(fmt.Sprintf("TestAsteriscKonaNetworkOrL2GenesisRequired-%v", gameType), func(t *testing.T) { - cfg := validConfigWithNoNetworks(t, gameType) - cfg.AsteriscKona.L2GenesisPaths = nil - require.ErrorIs(t, cfg.Check(), vm.ErrMissingL2Genesis) - }) - - t.Run(fmt.Sprintf("MaySpecifyNetworkAndCustomConfig-%v", gameType), func(t *testing.T) { - cfg := validConfig(t, gameType) - cfg.AsteriscKona.Networks = []string{validAsteriscKonaNetwork} - cfg.AsteriscKona.RollupConfigPaths = []string{"foo.json"} - cfg.AsteriscKona.L2GenesisPaths = []string{"genesis.json"} - require.NoError(t, cfg.Check()) - }) - - t.Run(fmt.Sprintf("TestNetworkMustBeValid-%v", gameType), func(t *testing.T) { - cfg := validConfig(t, gameType) - cfg.AsteriscKona.Networks = []string{"unknown"} - require.ErrorIs(t, cfg.Check(), vm.ErrNetworkUnknown) - }) - - t.Run(fmt.Sprintf("TestDebugInfoDisabled-%v", gameType), func(t *testing.T) { - cfg := validConfig(t, gameType) - require.False(t, cfg.AsteriscKona.DebugInfo) - }) - - t.Run(fmt.Sprintf("TestVMBinExists-%v", gameType), func(t *testing.T) { - cfg := validConfig(t, gameType) - cfg.AsteriscKona.VmBin = nonExistingFile - require.ErrorIs(t, cfg.Check(), vm.ErrMissingBin) - }) - - t.Run(fmt.Sprintf("TestServerExists-%v", gameType), func(t *testing.T) { - cfg := validConfig(t, gameType) - cfg.AsteriscKona.Server = nonExistingFile - require.ErrorIs(t, cfg.Check(), vm.ErrMissingServer) - }) - } } func TestDatadirRequired(t *testing.T) { @@ -857,29 +567,11 @@ func TestRequireConfigForMultipleGameTypesForCannon(t *testing.T) { require.ErrorIs(t, cfg.Check(), ErrMissingRollupRpc) } -func TestRequireConfigForMultipleGameTypesForAsterisc(t *testing.T) { - cfg := validConfig(t, gameTypes.AsteriscGameType) - cfg.GameTypes = []gameTypes.GameType{gameTypes.AsteriscGameType, gameTypes.AlphabetGameType} - // Set all required options and check its valid - cfg.RollupRpc = validRollupRpc - require.NoError(t, cfg.Check()) - - // Require asterisc specific args - cfg.AsteriscAbsolutePreState = "" - cfg.AsteriscAbsolutePreStateBaseURL = nil - require.ErrorIs(t, cfg.Check(), ErrMissingAsteriscAbsolutePreState) - cfg.AsteriscAbsolutePreState = validAsteriscAbsolutePreState - - // Require output asterisc specific args - cfg.RollupRpc = "" - require.ErrorIs(t, cfg.Check(), ErrMissingRollupRpc) -} - -func TestRequireConfigForMultipleGameTypesForCannonAndAsterisc(t *testing.T) { +func TestRequireConfigForMultipleGameTypesForCannonAndCannonKona(t *testing.T) { cfg := validConfig(t, gameTypes.CannonGameType) - applyValidConfigForAsterisc(t, &cfg) + applyValidConfigForCannonKona(t, &cfg) - cfg.GameTypes = []gameTypes.GameType{gameTypes.CannonGameType, gameTypes.AsteriscGameType, gameTypes.AlphabetGameType, gameTypes.FastGameType} + cfg.GameTypes = []gameTypes.GameType{gameTypes.CannonGameType, gameTypes.CannonKonaGameType, gameTypes.AlphabetGameType, gameTypes.FastGameType} // Set all required options and check its valid cfg.RollupRpc = validRollupRpc require.NoError(t, cfg.Check()) @@ -893,18 +585,15 @@ func TestRequireConfigForMultipleGameTypesForCannonAndAsterisc(t *testing.T) { require.NoError(t, err) cfg.Cannon.VmBin = vmBin - // Require asterisc specific args - cfg.AsteriscAbsolutePreState = "" - cfg.AsteriscAbsolutePreStateBaseURL = nil - require.ErrorIs(t, cfg.Check(), ErrMissingAsteriscAbsolutePreState) - cfg.AsteriscAbsolutePreState = validAsteriscAbsolutePreState + // Require cannon-kona specific args + cfg.CannonKonaAbsolutePreState = "" + cfg.CannonKonaAbsolutePreStateBaseURL = nil + require.ErrorIs(t, cfg.Check(), ErrMissingCannonKonaAbsolutePreState) + cfg.CannonKonaAbsolutePreStateBaseURL = validCannonKonaAbsolutePreStateBaseURL - cfg.Asterisc.Server = "" + cfg.CannonKona.Server = "" require.ErrorIs(t, cfg.Check(), vm.ErrMissingServer) - server := filepath.Join(tmpDir, validAsteriscOpProgramBin) - err = ensureExists(server) - require.NoError(t, err) - cfg.Asterisc.Server = server + cfg.CannonKona.Server = vmBin // Check final config is valid require.NoError(t, cfg.Check()) diff --git a/op-challenger/flags/flags.go b/op-challenger/flags/flags.go index be39ac13595..0c83b2c84a4 100644 --- a/op-challenger/flags/flags.go +++ b/op-challenger/flags/flags.go @@ -40,8 +40,6 @@ var ( faultDisputeVMs = []gameTypes.GameType{ gameTypes.CannonGameType, gameTypes.CannonKonaGameType, - gameTypes.AsteriscGameType, - gameTypes.AsteriscKonaGameType, gameTypes.SuperCannonGameType, gameTypes.SuperCannonKonaGameType, } @@ -108,7 +106,7 @@ var ( } L2ExperimentalEthRpcFlag = &cli.StringFlag{ Name: "l2-experimental-eth-rpc", - Usage: "L2 Address of L2 JSON-RPC endpoint to use (eth and debug namespace required with execution witness support) (cannon/asterisc game type only)", + Usage: "L2 Address of L2 JSON-RPC endpoint to use (eth and debug namespace required with execution witness support) (cannon game type only)", EnvVars: prefixEnvVars("L2_EXPERIMENTAL_ETH_RPC"), } MaxPendingTransactionsFlag = &cli.Uint64Flag{ @@ -223,51 +221,6 @@ var ( Value: false, Hidden: true, } - AsteriscBinFlag = &cli.StringFlag{ - Name: "asterisc-bin", - Usage: "Path to asterisc executable to use when generating trace data (asterisc game type only)", - EnvVars: prefixEnvVars("ASTERISC_BIN"), - } - AsteriscServerFlag = &cli.StringFlag{ - Name: "asterisc-server", - Usage: "Path to executable to use as pre-image oracle server when generating trace data (asterisc game 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 game type only)", - EnvVars: prefixEnvVars("ASTERISC_KONA_SERVER"), - } - AsteriscKonaL2CustomFlag = &cli.BoolFlag{ - Name: "asterisc-kona-l2-custom", - Usage: "Notify the kona-host that the L2 chain uses custom config to be loaded via the preimage oracle. " + - "WARNING: This is incompatible with on-chain testing and must only be used for testing purposes.", - EnvVars: prefixEnvVars("ASTERISC_KONA_L2_CUSTOM"), - Value: false, - Hidden: true, - } - AsteriscPreStateFlag = &cli.StringFlag{ - Name: "asterisc-prestate", - Usage: "Path to absolute prestate to use when generating trace data (asterisc game 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 game type only)", - EnvVars: prefixEnvVars("ASTERISC_KONA_PRESTATE"), - } - AsteriscSnapshotFreqFlag = &cli.UintFlag{ - Name: "asterisc-snapshot-freq", - Usage: "Frequency of asterisc snapshots to generate in VM steps (asterisc game type only)", - EnvVars: prefixEnvVars("ASTERISC_SNAPSHOT_FREQ"), - Value: config.DefaultAsteriscSnapshotFreq, - } - AsteriscInfoFreqFlag = &cli.UintFlag{ - Name: "asterisc-info-freq", - Usage: "Frequency of asterisc info log messages to generate in VM steps (asterisc game type only)", - EnvVars: prefixEnvVars("ASTERISC_INFO_FREQ"), - Value: config.DefaultAsteriscInfoFreq, - } GameWindowFlag = &cli.DurationFlag{ Name: "game-window", Usage: "The time window which the challenger will look for games to progress and claim bonds. " + @@ -331,14 +284,6 @@ var optionalFlags = []cli.Flag{ CannonKonaServerFlag, CannonKonaPreStateFlag, CannonKonaL2CustomFlag, - AsteriscBinFlag, - AsteriscServerFlag, - AsteriscKonaL2CustomFlag, - AsteriscKonaServerFlag, - AsteriscPreStateFlag, - AsteriscKonaPreStateFlag, - AsteriscSnapshotFreqFlag, - AsteriscInfoFreqFlag, GameWindowFlag, SelectiveClaimResolutionFlag, UnsafeAllowInvalidPrestate, @@ -476,55 +421,6 @@ func CheckCannonKonaFlags(ctx *cli.Context) error { return nil } -func CheckAsteriscBaseFlags(ctx *cli.Context, gameType gameTypes.GameType) error { - if !ctx.IsSet(flags.NetworkFlagName) && - !(RollupConfigFlag.IsSet(ctx, gameType) && L2GenesisFlag.IsSet(ctx, gameType)) { - return fmt.Errorf("flag %v or %v and %v is required", - flags.NetworkFlagName, RollupConfigFlag.EitherFlagName(gameType), L2GenesisFlag.EitherFlagName(gameType)) - } - if ctx.IsSet(flags.NetworkFlagName) && - (RollupConfigFlag.IsSet(ctx, gameTypes.AsteriscKonaGameType) || L2GenesisFlag.IsSet(ctx, gameTypes.AsteriscKonaGameType) || L1GenesisFlag.IsSet(ctx, gameTypes.AsteriscKonaGameType) || ctx.Bool(AsteriscKonaL2CustomFlag.Name)) { - return fmt.Errorf("flag %v can not be used with %v, %v, %v or %v", - flags.NetworkFlagName, RollupConfigFlag.EitherFlagName(gameTypes.AsteriscKonaGameType), L2GenesisFlag.EitherFlagName(gameTypes.AsteriscKonaGameType), L1GenesisFlag.EitherFlagName(gameTypes.AsteriscKonaGameType), AsteriscKonaL2CustomFlag.Name) - } - if !ctx.IsSet(AsteriscBinFlag.Name) { - return fmt.Errorf("flag %s is required", AsteriscBinFlag.Name) - } - return nil -} - -func CheckAsteriscFlags(ctx *cli.Context) error { - if err := checkOutputProviderFlags(ctx); err != nil { - return err - } - if err := CheckAsteriscBaseFlags(ctx, gameTypes.AsteriscGameType); err != nil { - return err - } - if !ctx.IsSet(AsteriscServerFlag.Name) { - return fmt.Errorf("flag %s is required", AsteriscServerFlag.Name) - } - if !PreStatesURLFlag.IsSet(ctx, gameTypes.AsteriscGameType) && !ctx.IsSet(AsteriscPreStateFlag.Name) { - return fmt.Errorf("flag %s or %s is required", PreStatesURLFlag.EitherFlagName(gameTypes.AsteriscGameType), AsteriscPreStateFlag.Name) - } - return nil -} - -func CheckAsteriscKonaFlags(ctx *cli.Context) error { - if err := checkOutputProviderFlags(ctx); err != nil { - return err - } - if err := CheckAsteriscBaseFlags(ctx, gameTypes.AsteriscKonaGameType); err != nil { - return err - } - if !ctx.IsSet(AsteriscKonaServerFlag.Name) { - return fmt.Errorf("flag %s is required", AsteriscKonaServerFlag.Name) - } - if !PreStatesURLFlag.IsSet(ctx, gameTypes.AsteriscKonaGameType) && !ctx.IsSet(AsteriscKonaPreStateFlag.Name) { - return fmt.Errorf("flag %s or %s is required", PreStatesURLFlag.EitherFlagName(gameTypes.AsteriscKonaGameType), AsteriscKonaPreStateFlag.Name) - } - return nil -} - func CheckRequired(ctx *cli.Context, types []gameTypes.GameType) error { for _, f := range requiredFlags { if !ctx.IsSet(f.Names()[0]) { @@ -544,14 +440,6 @@ func CheckRequired(ctx *cli.Context, types []gameTypes.GameType) error { if err := CheckCannonKonaFlags(ctx); err != nil { return err } - case gameTypes.AsteriscGameType: - if err := CheckAsteriscFlags(ctx); err != nil { - return err - } - case gameTypes.AsteriscKonaGameType: - if err := CheckAsteriscKonaFlags(ctx); err != nil { - return err - } case gameTypes.SuperCannonGameType, gameTypes.SuperPermissionedGameType: if err := CheckSuperCannonFlags(ctx); err != nil { return err @@ -693,14 +581,6 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro if err != nil { return nil, err } - asteriscPreStatesURL, err := getPrestatesUrl(gameTypes.AsteriscGameType) - if err != nil { - return nil, err - } - asteriscKonaPreStatesURL, err := getPrestatesUrl(gameTypes.AsteriscKonaGameType) - if err != nil { - return nil, err - } networks := ctx.StringSlice(flags.NetworkFlagName) l1EthRpc := ctx.String(L1EthRpcFlag.Name) l1Beacon := ctx.String(L1BeaconFlag.Name) @@ -765,51 +645,12 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro CannonKonaAbsolutePreState: ctx.String(CannonKonaPreStateFlag.Name), CannonKonaAbsolutePreStateBaseURL: cannonKonaPreStatesURL, Datadir: ctx.String(DatadirFlag.Name), - Asterisc: vm.Config{ - VmType: gameTypes.AsteriscGameType, - L1: l1EthRpc, - L1Beacon: l1Beacon, - L2s: l2Rpcs, - L2Experimental: l2Experimental, - VmBin: ctx.String(AsteriscBinFlag.Name), - Server: ctx.String(AsteriscServerFlag.Name), - Networks: networks, - RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, gameTypes.AsteriscGameType), - L1GenesisPath: L1GenesisFlag.String(ctx, gameTypes.AsteriscGameType), - L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, gameTypes.AsteriscGameType), - DepsetConfigPath: DepsetConfigFlag.String(ctx, gameTypes.AsteriscGameType), - SnapshotFreq: ctx.Uint(AsteriscSnapshotFreqFlag.Name), - InfoFreq: ctx.Uint(AsteriscInfoFreqFlag.Name), - BinarySnapshots: true, - }, - AsteriscAbsolutePreState: ctx.String(AsteriscPreStateFlag.Name), - AsteriscAbsolutePreStateBaseURL: asteriscPreStatesURL, - AsteriscKona: vm.Config{ - VmType: gameTypes.AsteriscKonaGameType, - L1: l1EthRpc, - L1Beacon: l1Beacon, - L2s: l2Rpcs, - L2Experimental: l2Experimental, - VmBin: ctx.String(AsteriscBinFlag.Name), - Server: ctx.String(AsteriscKonaServerFlag.Name), - Networks: networks, - L2Custom: ctx.Bool(AsteriscKonaL2CustomFlag.Name), - RollupConfigPaths: RollupConfigFlag.StringSlice(ctx, gameTypes.AsteriscKonaGameType), - L1GenesisPath: L1GenesisFlag.String(ctx, gameTypes.AsteriscKonaGameType), - L2GenesisPaths: L2GenesisFlag.StringSlice(ctx, gameTypes.AsteriscKonaGameType), - DepsetConfigPath: DepsetConfigFlag.String(ctx, gameTypes.AsteriscKonaGameType), - SnapshotFreq: ctx.Uint(AsteriscSnapshotFreqFlag.Name), - InfoFreq: ctx.Uint(AsteriscInfoFreqFlag.Name), - BinarySnapshots: true, - }, - AsteriscKonaAbsolutePreState: ctx.String(AsteriscKonaPreStateFlag.Name), - AsteriscKonaAbsolutePreStateBaseURL: asteriscKonaPreStatesURL, - TxMgrConfig: txMgrConfig, - MetricsConfig: metricsConfig, - PprofConfig: pprofConfig, - SelectiveClaimResolution: ctx.Bool(SelectiveClaimResolutionFlag.Name), - AllowInvalidPrestate: ctx.Bool(UnsafeAllowInvalidPrestate.Name), - ResponseDelay: ctx.Duration(ResponseDelayFlag.Name), - ResponseDelayAfter: ctx.Uint64(ResponseDelayAfterFlag.Name), + TxMgrConfig: txMgrConfig, + MetricsConfig: metricsConfig, + PprofConfig: pprofConfig, + SelectiveClaimResolution: ctx.Bool(SelectiveClaimResolutionFlag.Name), + AllowInvalidPrestate: ctx.Bool(UnsafeAllowInvalidPrestate.Name), + ResponseDelay: ctx.Duration(ResponseDelayFlag.Name), + ResponseDelayAfter: ctx.Uint64(ResponseDelayAfterFlag.Name), }, nil } diff --git a/op-challenger/game/fault/contracts/detect.go b/op-challenger/game/fault/contracts/detect.go index afdee4453ba..3cdaf9d5ed8 100644 --- a/op-challenger/game/fault/contracts/detect.go +++ b/op-challenger/game/fault/contracts/detect.go @@ -32,10 +32,8 @@ func DetectGameType(ctx context.Context, addr common.Address, caller *batching.M case gameTypes.CannonGameType, gameTypes.PermissionedGameType, gameTypes.CannonKonaGameType, - gameTypes.AsteriscGameType, gameTypes.AlphabetGameType, gameTypes.FastGameType, - gameTypes.AsteriscKonaGameType, gameTypes.SuperCannonGameType, gameTypes.SuperPermissionedGameType, gameTypes.SuperCannonKonaGameType: diff --git a/op-challenger/game/fault/contracts/disputegame.go b/op-challenger/game/fault/contracts/disputegame.go index 09e965aeae3..0a2f688d972 100644 --- a/op-challenger/game/fault/contracts/disputegame.go +++ b/op-challenger/game/fault/contracts/disputegame.go @@ -46,10 +46,8 @@ func NewDisputeGameContract(ctx context.Context, metrics metrics.ContractMetrice case gameTypes.CannonGameType, gameTypes.PermissionedGameType, gameTypes.CannonKonaGameType, - gameTypes.AsteriscGameType, gameTypes.AlphabetGameType, - gameTypes.FastGameType, - gameTypes.AsteriscKonaGameType: + gameTypes.FastGameType: return NewPreInteropFaultDisputeGameContract(ctx, metrics, addr, caller) case gameTypes.OptimisticZKGameType: return NewOptimisticZKDisputeGameContract(metrics, addr, caller) diff --git a/op-challenger/game/fault/register.go b/op-challenger/game/fault/register.go index 4cec25587a7..afa4fb9fe2b 100644 --- a/op-challenger/game/fault/register.go +++ b/op-challenger/game/fault/register.go @@ -95,20 +95,6 @@ func RegisterGameTypes( } registerTasks = append(registerTasks, NewSuperCannonRegisterTask(gameTypes.SuperPermissionedGameType, cfg, m, vm.NewOpProgramServerExecutor(logger), rootProvider, syncValidator)) } - if cfg.GameTypeEnabled(gameTypes.AsteriscGameType) { - l2HeaderSource, rollupClient, syncValidator, err := clients.SingleChainClients() - if err != nil { - return err - } - registerTasks = append(registerTasks, NewAsteriscRegisterTask(gameTypes.AsteriscGameType, cfg, m, vm.NewOpProgramServerExecutor(logger), l2HeaderSource, rollupClient, syncValidator)) - } - if cfg.GameTypeEnabled(gameTypes.AsteriscKonaGameType) { - l2HeaderSource, rollupClient, syncValidator, err := clients.SingleChainClients() - if err != nil { - return err - } - registerTasks = append(registerTasks, NewAsteriscKonaRegisterTask(gameTypes.AsteriscKonaGameType, cfg, m, vm.NewKonaExecutor(), l2HeaderSource, rollupClient, syncValidator)) - } if cfg.GameTypeEnabled(gameTypes.FastGameType) { l2HeaderSource, rollupClient, syncValidator, err := clients.SingleChainClients() if err != nil { diff --git a/op-challenger/game/fault/register_task.go b/op-challenger/game/fault/register_task.go index 13cf104a06b..be1a8b1c554 100644 --- a/op-challenger/game/fault/register_task.go +++ b/op-challenger/game/fault/register_task.go @@ -12,7 +12,6 @@ import ( "github.com/ethereum-optimism/optimism/op-challenger/game/fault/contracts" "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace" "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/alphabet" - "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/asterisc" "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/cannon" "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/outputs" "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/prestates" @@ -163,74 +162,6 @@ func newCannonVMRegisterTaskWithConfig( } } -func NewAsteriscRegisterTask(gameType gameTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor, l2Client utils.L2HeaderSource, rollupClient outputs.OutputRollupClient, syncValidator generic.SyncValidator) *RegisterTask { - stateConverter := asterisc.NewStateConverter(cfg.Asterisc) - return &RegisterTask{ - gameType: gameType, - syncValidator: syncValidator, - getTopPrestateProvider: func(ctx context.Context, prestateBlock uint64) (faultTypes.PrestateProvider, error) { - return outputs.NewPrestateProvider(rollupClient, prestateBlock), nil - }, - getBottomPrestateProvider: cachePrestates( - gameType, - stateConverter, - m, - cfg.AsteriscAbsolutePreStateBaseURL, - cfg.AsteriscAbsolutePreState, - filepath.Join(cfg.Datadir, "asterisc-prestates"), - func(ctx context.Context, path string) faultTypes.PrestateProvider { - return vm.NewPrestateProvider(path, stateConverter) - }), - newTraceAccessor: func( - logger log.Logger, - m metrics.Metricer, - prestateProvider faultTypes.PrestateProvider, - vmPrestateProvider faultTypes.PrestateProvider, - dir string, - l1Head eth.BlockID, - splitDepth faultTypes.Depth, - prestateBlock uint64, - poststateBlock uint64) (*trace.Accessor, error) { - provider := vmPrestateProvider.(*vm.PrestateProvider) - return outputs.NewOutputAsteriscTraceAccessor(logger, m, cfg.Asterisc, serverExecutor, l2Client, prestateProvider, provider.PrestatePath(), rollupClient, dir, l1Head, splitDepth, prestateBlock, poststateBlock) - }, - } -} - -func NewAsteriscKonaRegisterTask(gameType gameTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor, l2Client utils.L2HeaderSource, rollupClient outputs.OutputRollupClient, syncValidator generic.SyncValidator) *RegisterTask { - stateConverter := asterisc.NewStateConverter(cfg.Asterisc) - return &RegisterTask{ - gameType: gameType, - syncValidator: syncValidator, - getTopPrestateProvider: func(ctx context.Context, prestateBlock uint64) (faultTypes.PrestateProvider, error) { - return outputs.NewPrestateProvider(rollupClient, prestateBlock), nil - }, - getBottomPrestateProvider: cachePrestates( - gameType, - stateConverter, - m, - cfg.AsteriscKonaAbsolutePreStateBaseURL, - cfg.AsteriscKonaAbsolutePreState, - filepath.Join(cfg.Datadir, "asterisc-kona-prestates"), - func(ctx context.Context, path string) faultTypes.PrestateProvider { - return vm.NewPrestateProvider(path, stateConverter) - }), - newTraceAccessor: func( - logger log.Logger, - m metrics.Metricer, - prestateProvider faultTypes.PrestateProvider, - vmPrestateProvider faultTypes.PrestateProvider, - dir string, - l1Head eth.BlockID, - splitDepth faultTypes.Depth, - prestateBlock uint64, - poststateBlock uint64) (*trace.Accessor, error) { - provider := vmPrestateProvider.(*vm.PrestateProvider) - return outputs.NewOutputAsteriscTraceAccessor(logger, m, cfg.AsteriscKona, serverExecutor, l2Client, prestateProvider, provider.PrestatePath(), rollupClient, dir, l1Head, splitDepth, prestateBlock, poststateBlock) - }, - } -} - func NewAlphabetRegisterTask(gameType gameTypes.GameType, l2Client utils.L2HeaderSource, rollupClient outputs.OutputRollupClient, syncValidator generic.SyncValidator) *RegisterTask { return &RegisterTask{ gameType: gameType, diff --git a/op-challenger/game/fault/trace/asterisc/provider.go b/op-challenger/game/fault/trace/asterisc/provider.go deleted file mode 100644 index c622b6ed9dd..00000000000 --- a/op-challenger/game/fault/trace/asterisc/provider.go +++ /dev/null @@ -1,198 +0,0 @@ -package asterisc - -import ( - "context" - "encoding/json" - "errors" - "fmt" - "io" - "math" - "os" - "path/filepath" - - "github.com/ethereum-optimism/optimism/op-challenger/config" - "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-program/host/kvstore" - kvtypes "github.com/ethereum-optimism/optimism/op-program/host/types" - "github.com/ethereum-optimism/optimism/op-service/ioutil" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/log" -) - -type AsteriscTraceProvider struct { - logger log.Logger - dir string - prestate string - generator utils.ProofGenerator - gameDepth types.Depth - preimageLoader *utils.PreimageLoader - stateConverter vm.StateConverter - cfg vm.Config - - types.PrestateProvider - - // lastStep stores the last step in the actual trace if known. 0 indicates unknown. - // Cached as an optimisation to avoid repeatedly attempting to execute beyond the end of the trace. - lastStep uint64 -} - -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, vmCfg, asteriscPrestate, localInputs), - gameDepth: gameDepth, - preimageLoader: utils.NewPreimageLoader(func() (utils.PreimageSource, error) { - return kvstore.NewDiskKV(logger, vm.PreimageDir(dir), kvtypes.DataFormatFile) - }), - PrestateProvider: prestateProvider, - stateConverter: NewStateConverter(cfg), - cfg: cfg, - } -} - -func (p *AsteriscTraceProvider) Get(ctx context.Context, pos types.Position) (common.Hash, error) { - traceIndex := pos.TraceIndex(p.gameDepth) - if !traceIndex.IsUint64() { - return common.Hash{}, errors.New("trace index out of bounds") - } - proof, err := p.loadProof(ctx, traceIndex.Uint64()) - if err != nil { - return common.Hash{}, err - } - value := proof.ClaimValue - - if value == (common.Hash{}) { - return common.Hash{}, errors.New("proof missing post hash") - } - return value, nil -} - -func (p *AsteriscTraceProvider) GetStepData(ctx context.Context, pos types.Position) ([]byte, []byte, *types.PreimageOracleData, error) { - traceIndex := pos.TraceIndex(p.gameDepth) - if !traceIndex.IsUint64() { - return nil, nil, nil, errors.New("trace index out of bounds") - } - proof, err := p.loadProof(ctx, traceIndex.Uint64()) - if err != nil { - return nil, nil, nil, err - } - value := ([]byte)(proof.StateData) - if len(value) == 0 { - return nil, nil, nil, errors.New("proof missing state data") - } - data := ([]byte)(proof.ProofData) - if data == nil { - return nil, nil, nil, errors.New("proof missing proof data") - } - oracleData, err := p.preimageLoader.LoadPreimage(proof) - if err != nil { - return nil, nil, nil, fmt.Errorf("failed to load preimage: %w", err) - } - return value, data, oracleData, nil -} - -func (p *AsteriscTraceProvider) GetL2BlockNumberChallenge(_ context.Context) (*types.InvalidL2BlockNumberChallenge, error) { - return nil, types.ErrL2BlockNumberValid -} - -// loadProof will attempt to load or generate the proof data at the specified index -// If the requested index is beyond the end of the actual trace it is extended with no-op instructions. -func (p *AsteriscTraceProvider) loadProof(ctx context.Context, i uint64) (*utils.ProofData, error) { - // Attempt to read the last step from disk cache - if p.lastStep == 0 { - step, err := utils.ReadLastStep(p.dir) - if err != nil { - p.logger.Warn("Failed to read last step from disk cache", "err", err) - } else { - p.lastStep = step - } - } - // If the last step is tracked, set i to the last step to generate or load the final proof - if p.lastStep != 0 && i > p.lastStep { - i = p.lastStep - } - path := filepath.Join(p.dir, utils.ProofsDir, fmt.Sprintf("%d.json.gz", i)) - file, err := ioutil.OpenDecompressed(path) - if errors.Is(err, os.ErrNotExist) { - if err := p.generator.GenerateProof(ctx, p.dir, i); err != nil { - return nil, fmt.Errorf("generate asterisc trace with proof at %v: %w", i, err) - } - // Try opening the file again now and it should exist. - file, err = ioutil.OpenDecompressed(path) - if errors.Is(err, os.ErrNotExist) { - // Expected proof wasn't generated, check if we reached the end of execution - proof, step, exited, err := p.stateConverter.ConvertStateToProof(ctx, vm.FinalStatePath(p.dir, p.cfg.BinarySnapshots)) - if err != nil { - return nil, err - } - if exited && step <= i { - p.logger.Warn("Requested proof was after the program exited", "proof", i, "last", step) - // The final instruction has already been applied to this state, so the last step we can execute - // is one before its Step value. - p.lastStep = step - 1 - // Extend the trace out to the full length using a no-op instruction that doesn't change any state - // No execution is done, so no proof-data or oracle values are required. - if err := utils.WriteLastStep(p.dir, proof, p.lastStep); err != nil { - p.logger.Warn("Failed to write last step to disk cache", "step", p.lastStep) - } - return proof, nil - } else { - return nil, fmt.Errorf("expected proof not generated but final state was not exited, requested step %v, final state at step %v", i, step) - } - } - } - if err != nil { - return nil, fmt.Errorf("cannot open proof file (%v): %w", path, err) - } - defer file.Close() - var proof utils.ProofData - err = json.NewDecoder(file).Decode(&proof) - if err != nil { - return nil, fmt.Errorf("failed to read proof (%v): %w", path, err) - } - return &proof, nil -} - -// AsteriscTraceProviderForTest is a AsteriscTraceProvider that can find the step referencing the preimage read -// Only to be used for testing -type AsteriscTraceProviderForTest struct { - *AsteriscTraceProvider -} - -func NewTraceProviderForTest(logger log.Logger, m vm.Metricer, cfg *config.Config, localInputs utils.LocalGameInputs, dir string, gameDepth types.Depth) *AsteriscTraceProviderForTest { - p := &AsteriscTraceProvider{ - logger: logger, - dir: dir, - prestate: cfg.AsteriscAbsolutePreState, - generator: vm.NewExecutor(logger, m, cfg.Asterisc, vm.NewOpProgramServerExecutor(logger), cfg.AsteriscAbsolutePreState, localInputs), - gameDepth: gameDepth, - preimageLoader: utils.NewPreimageLoader(func() (utils.PreimageSource, error) { - return kvstore.NewDiskKV(logger, vm.PreimageDir(dir), kvtypes.DataFormatFile) - }), - stateConverter: NewStateConverter(cfg.Asterisc), - cfg: cfg.Asterisc, - } - return &AsteriscTraceProviderForTest{p} -} - -func (p *AsteriscTraceProviderForTest) FindStep(ctx context.Context, start uint64, preimage utils.PreimageOpt) (uint64, error) { - // Run asterisc to find the step that meets the preimage conditions - if err := p.generator.(*vm.Executor).DoGenerateProof(ctx, p.dir, start, math.MaxUint64, preimage()...); err != nil { - return 0, fmt.Errorf("generate asterisc trace (until preimage read): %w", err) - } - // Load the step from the state asterisc finished with - _, step, exited, err := p.stateConverter.ConvertStateToProof(ctx, vm.FinalStatePath(p.dir, p.cfg.BinarySnapshots)) - if err != nil { - return 0, fmt.Errorf("failed to load final state: %w", err) - } - // Check we didn't get to the end of the trace without finding the preimage read we were looking for - if exited { - return 0, fmt.Errorf("preimage read not found: %w", io.EOF) - } - // The state is the post-state so the step we want to execute to read the preimage is step - 1. - return step - 1, nil -} diff --git a/op-challenger/game/fault/trace/asterisc/provider_test.go b/op-challenger/game/fault/trace/asterisc/provider_test.go deleted file mode 100644 index 609fa143e86..00000000000 --- a/op-challenger/game/fault/trace/asterisc/provider_test.go +++ /dev/null @@ -1,278 +0,0 @@ -package asterisc - -import ( - "context" - "embed" - "encoding/json" - "fmt" - "math" - "math/big" - "os" - "path/filepath" - "testing" - - "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-service/ioutil" - "github.com/ethereum-optimism/optimism/op-service/testlog" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/log" - "github.com/stretchr/testify/require" -) - -//go:embed test_data -var testData embed.FS -var asteriscWitnessLen = 362 - -func PositionFromTraceIndex(provider *AsteriscTraceProvider, idx *big.Int) types.Position { - return types.NewPosition(provider.gameDepth, idx) -} - -func TestGet(t *testing.T) { - dataDir, prestate := setupTestData(t) - t.Run("ExistingProof", func(t *testing.T) { - provider, generator := setupWithTestData(t, dataDir, prestate) - value, err := provider.Get(context.Background(), PositionFromTraceIndex(provider, common.Big0)) - require.NoError(t, err) - require.Equal(t, common.HexToHash("0x034689707b571db46b32c9e433def18e648f4e1fa9e5abd4012e7913031bfc10"), value) - require.Empty(t, generator.generated) - }) - - t.Run("ErrorsTraceIndexOutOfBounds", func(t *testing.T) { - provider, generator := setupWithTestData(t, dataDir, prestate) - largePosition := PositionFromTraceIndex(provider, new(big.Int).Mul(new(big.Int).SetUint64(math.MaxUint64), big.NewInt(2))) - _, err := provider.Get(context.Background(), largePosition) - require.ErrorContains(t, err, "trace index out of bounds") - require.Empty(t, generator.generated) - }) - - t.Run("MissingPostHash", func(t *testing.T) { - provider, generator := setupWithTestData(t, dataDir, prestate) - _, err := provider.Get(context.Background(), PositionFromTraceIndex(provider, big.NewInt(1))) - require.ErrorContains(t, err, "missing post hash") - require.Empty(t, generator.generated) - }) - - t.Run("IgnoreUnknownFields", func(t *testing.T) { - provider, generator := setupWithTestData(t, dataDir, prestate) - value, err := provider.Get(context.Background(), PositionFromTraceIndex(provider, big.NewInt(2))) - require.NoError(t, err) - expected := common.HexToHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb") - require.Equal(t, expected, value) - require.Empty(t, generator.generated) - }) -} - -func TestGetStepData(t *testing.T) { - t.Run("ExistingProof", func(t *testing.T) { - dataDir, prestate := setupTestData(t) - provider, generator := setupWithTestData(t, dataDir, prestate) - value, proof, data, err := provider.GetStepData(context.Background(), PositionFromTraceIndex(provider, common.Big0)) - require.NoError(t, err) - expected := common.FromHex("0x354cfaf28a5b60c3f64f22f9f171b64aa067f90c6de6c96f725f44c5cf9f8ac1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080e080000000000000000000000007f0000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") - require.Equal(t, expected, value) - expectedProof := common.FromHex("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") - require.Equal(t, expectedProof, proof) - // TODO: Need to add some oracle data - require.Nil(t, data) - require.Empty(t, generator.generated) - }) - - t.Run("ErrorsTraceIndexOutOfBounds", func(t *testing.T) { - dataDir, prestate := setupTestData(t) - provider, generator := setupWithTestData(t, dataDir, prestate) - largePosition := PositionFromTraceIndex(provider, new(big.Int).Mul(new(big.Int).SetUint64(math.MaxUint64), big.NewInt(2))) - _, _, _, err := provider.GetStepData(context.Background(), largePosition) - require.ErrorContains(t, err, "trace index out of bounds") - require.Empty(t, generator.generated) - }) - - t.Run("GenerateProof", func(t *testing.T) { - dataDir, prestate := setupTestData(t) - provider, generator := setupWithTestData(t, dataDir, prestate) - generator.finalState = &VMState{ - Step: 10, - Exited: true, - Witness: make([]byte, asteriscWitnessLen), - } - generator.proof = &utils.ProofData{ - ClaimValue: common.Hash{0xaa}, - StateData: []byte{0xbb}, - ProofData: []byte{0xcc}, - OracleKey: common.Hash{0xdd}.Bytes(), - OracleValue: []byte{0xdd}, - OracleOffset: 10, - } - preimage, proof, data, err := provider.GetStepData(context.Background(), PositionFromTraceIndex(provider, big.NewInt(4))) - require.NoError(t, err) - require.Contains(t, generator.generated, 4, "should have tried to generate the proof") - - require.EqualValues(t, generator.proof.StateData, preimage) - require.EqualValues(t, generator.proof.ProofData, proof) - expectedData := types.NewPreimageOracleData(generator.proof.OracleKey, generator.proof.OracleValue, generator.proof.OracleOffset) - require.EqualValues(t, expectedData, data) - }) - - t.Run("ProofAfterEndOfTrace", func(t *testing.T) { - dataDir, prestate := setupTestData(t) - provider, generator := setupWithTestData(t, dataDir, prestate) - generator.finalState = &VMState{ - Step: 10, - Exited: true, - Witness: make([]byte, asteriscWitnessLen), - } - generator.proof = &utils.ProofData{ - ClaimValue: common.Hash{0xaa}, - StateData: []byte{0xbb}, - ProofData: []byte{0xcc}, - OracleKey: common.Hash{0xdd}.Bytes(), - OracleValue: []byte{0xdd}, - OracleOffset: 10, - } - preimage, proof, data, err := provider.GetStepData(context.Background(), PositionFromTraceIndex(provider, big.NewInt(7000))) - require.NoError(t, err) - require.Contains(t, generator.generated, 7000, "should have tried to generate the proof") - - witness := generator.finalState.Witness - require.EqualValues(t, witness, preimage) - require.Equal(t, []byte{}, proof) - require.Nil(t, data) - }) - - t.Run("ReadLastStepFromDisk", func(t *testing.T) { - dataDir, prestate := setupTestData(t) - provider, initGenerator := setupWithTestData(t, dataDir, prestate) - initGenerator.finalState = &VMState{ - Step: 10, - Exited: true, - Witness: make([]byte, asteriscWitnessLen), - } - initGenerator.proof = &utils.ProofData{ - ClaimValue: common.Hash{0xaa}, - StateData: []byte{0xbb}, - ProofData: []byte{0xcc}, - OracleKey: common.Hash{0xdd}.Bytes(), - OracleValue: []byte{0xdd}, - OracleOffset: 10, - } - _, _, _, err := provider.GetStepData(context.Background(), PositionFromTraceIndex(provider, big.NewInt(7000))) - require.NoError(t, err) - require.Contains(t, initGenerator.generated, 7000, "should have tried to generate the proof") - - provider, generator := setupWithTestData(t, dataDir, prestate) - generator.finalState = &VMState{ - Step: 10, - Exited: true, - Witness: make([]byte, asteriscWitnessLen), - } - generator.proof = &utils.ProofData{ - ClaimValue: common.Hash{0xaa}, - StateData: []byte{0xbb}, - ProofData: []byte{0xcc}, - } - preimage, proof, data, err := provider.GetStepData(context.Background(), PositionFromTraceIndex(provider, big.NewInt(7000))) - require.NoError(t, err) - require.Empty(t, generator.generated, "should not have to generate the proof again") - - require.EqualValues(t, initGenerator.finalState.Witness, preimage) - require.Empty(t, proof) - require.Nil(t, data) - }) - - t.Run("MissingStateData", func(t *testing.T) { - dataDir, prestate := setupTestData(t) - provider, generator := setupWithTestData(t, dataDir, prestate) - _, _, _, err := provider.GetStepData(context.Background(), PositionFromTraceIndex(provider, big.NewInt(1))) - require.ErrorContains(t, err, "missing state data") - require.Empty(t, generator.generated) - }) - - t.Run("IgnoreUnknownFields", func(t *testing.T) { - dataDir, prestate := setupTestData(t) - provider, generator := setupWithTestData(t, dataDir, prestate) - value, proof, data, err := provider.GetStepData(context.Background(), PositionFromTraceIndex(provider, big.NewInt(2))) - require.NoError(t, err) - expected := common.FromHex("cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc") - require.Equal(t, expected, value) - expectedProof := common.FromHex("dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd") - require.Equal(t, expectedProof, proof) - require.Empty(t, generator.generated) - require.Nil(t, data) - }) -} - -func setupTestData(t *testing.T) (string, string) { - srcDir := filepath.Join("test_data", "proofs") - entries, err := testData.ReadDir(srcDir) - require.NoError(t, err) - dataDir := t.TempDir() - require.NoError(t, os.Mkdir(filepath.Join(dataDir, utils.ProofsDir), 0o777)) - for _, entry := range entries { - path := filepath.Join(srcDir, entry.Name()) - file, err := testData.ReadFile(path) - require.NoErrorf(t, err, "reading %v", path) - proofFile := filepath.Join(dataDir, utils.ProofsDir, entry.Name()+".gz") - err = ioutil.WriteCompressedBytes(proofFile, file, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0o644) - require.NoErrorf(t, err, "writing %v", path) - } - return dataDir, "state.json" -} - -func setupWithTestData(t *testing.T, dataDir string, prestate string) (*AsteriscTraceProvider, *stubGenerator) { - generator := &stubGenerator{} - return &AsteriscTraceProvider{ - logger: testlog.Logger(t, log.LevelInfo), - dir: dataDir, - generator: generator, - prestate: filepath.Join(dataDir, prestate), - gameDepth: 63, - stateConverter: generator, - }, generator -} - -type stubGenerator struct { - generated []int // Using int makes assertions easier - finalState *VMState - proof *utils.ProofData - - finalStatePath string -} - -func (e *stubGenerator) ConvertStateToProof(ctx context.Context, statePath string) (*utils.ProofData, uint64, bool, error) { - if statePath == e.finalStatePath { - return &utils.ProofData{ - ClaimValue: e.finalState.StateHash, - StateData: e.finalState.Witness, - ProofData: []byte{}, - }, e.finalState.Step, e.finalState.Exited, nil - } else { - return nil, 0, false, fmt.Errorf("loading unexpected state: %s, only support: %s", statePath, e.finalStatePath) - } -} - -func (e *stubGenerator) GenerateProof(ctx context.Context, dir string, i uint64) error { - e.generated = append(e.generated, int(i)) - var proofFile string - var data []byte - var err error - if e.finalState != nil && e.finalState.Step <= i { - // Requesting a trace index past the end of the trace - proofFile = vm.FinalStatePath(dir, false) - e.finalStatePath = proofFile - data, err = json.Marshal(e.finalState) - if err != nil { - return err - } - return ioutil.WriteCompressedBytes(proofFile, data, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0o644) - } - if e.proof != nil { - proofFile = filepath.Join(dir, utils.ProofsDir, fmt.Sprintf("%d.json.gz", i)) - data, err = json.Marshal(e.proof) - if err != nil { - return err - } - return ioutil.WriteCompressedBytes(proofFile, data, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0o644) - } - return nil -} diff --git a/op-challenger/game/fault/trace/asterisc/state_converter.go b/op-challenger/game/fault/trace/asterisc/state_converter.go deleted file mode 100644 index 67b99f07db0..00000000000 --- a/op-challenger/game/fault/trace/asterisc/state_converter.go +++ /dev/null @@ -1,70 +0,0 @@ -package asterisc - -import ( - "bytes" - "context" - "encoding/json" - "fmt" - "os/exec" - - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/common/hexutil" - - "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/utils" - "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/vm" -) - -// The state struct will be read from json. -// other fields included in json are specific to FPVM implementation, and not required for trace provider. -type VMState struct { - PC uint64 `json:"pc"` - Exited bool `json:"exited"` - Step uint64 `json:"step"` - Witness hexutil.Bytes `json:"witness"` - StateHash common.Hash `json:"stateHash"` -} - -type StateConverter struct { - vmConfig vm.Config - cmdExecutor func(ctx context.Context, binary string, args ...string) (stdOut string, stdErr string, err error) -} - -func NewStateConverter(vmConfig vm.Config) *StateConverter { - return &StateConverter{ - vmConfig: vmConfig, - cmdExecutor: runCmd, - } -} - -func (c *StateConverter) ConvertStateToProof(ctx context.Context, statePath string) (*utils.ProofData, uint64, bool, error) { - stdOut, stdErr, err := c.cmdExecutor(ctx, c.vmConfig.VmBin, "witness", "--input", statePath) - if err != nil { - return nil, 0, false, fmt.Errorf("state conversion failed: %w (%s)", err, stdErr) - } - var data VMState - if err := json.Unmarshal([]byte(stdOut), &data); err != nil { - return nil, 0, false, fmt.Errorf("failed to parse state data: %w", err) - } - // Extend the trace out to the full length using a no-op instruction that doesn't change any state - // No execution is done, so no proof-data or oracle values are required. - return &utils.ProofData{ - ClaimValue: data.StateHash, - StateData: data.Witness, - ProofData: []byte{}, - OracleKey: nil, - OracleValue: nil, - OracleOffset: 0, - }, data.Step, data.Exited, nil -} - -func runCmd(ctx context.Context, binary string, args ...string) (stdOut string, stdErr string, err error) { - var outBuf bytes.Buffer - var errBuf bytes.Buffer - cmd := exec.CommandContext(ctx, binary, args...) - cmd.Stdout = &outBuf - cmd.Stderr = &errBuf - err = cmd.Run() - stdOut = outBuf.String() - stdErr = errBuf.String() - return -} diff --git a/op-challenger/game/fault/trace/asterisc/state_converter_test.go b/op-challenger/game/fault/trace/asterisc/state_converter_test.go deleted file mode 100644 index 8a3d9c4b269..00000000000 --- a/op-challenger/game/fault/trace/asterisc/state_converter_test.go +++ /dev/null @@ -1,79 +0,0 @@ -package asterisc - -import ( - "context" - "encoding/json" - "errors" - "testing" - - "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/vm" - "github.com/ethereum/go-ethereum/common" - "github.com/stretchr/testify/require" -) - -const testBinary = "./somewhere/asterisc" - -func TestStateConverter(t *testing.T) { - setup := func(t *testing.T) (*StateConverter, *capturingExecutor) { - vmCfg := vm.Config{ - VmBin: testBinary, - } - executor := &capturingExecutor{} - converter := NewStateConverter(vmCfg) - converter.cmdExecutor = executor.exec - return converter, executor - } - - t.Run("Valid", func(t *testing.T) { - converter, executor := setup(t) - data := VMState{ - Witness: []byte{1, 2, 3, 4}, - StateHash: common.Hash{0xab}, - Step: 42, - Exited: true, - PC: 11, - } - ser, err := json.Marshal(data) - require.NoError(t, err) - executor.stdOut = string(ser) - proof, step, exited, err := converter.ConvertStateToProof(context.Background(), "foo.json") - require.NoError(t, err) - require.Equal(t, data.Exited, exited) - require.Equal(t, data.Step, step) - require.Equal(t, data.StateHash, proof.ClaimValue) - require.Equal(t, data.Witness, proof.StateData) - require.NotNil(t, proof.ProofData, "later validations require this to be non-nil") - - require.Equal(t, testBinary, executor.binary) - require.Equal(t, []string{"witness", "--input", "foo.json"}, executor.args) - }) - - t.Run("CommandError", func(t *testing.T) { - converter, executor := setup(t) - executor.err = errors.New("boom") - _, _, _, err := converter.ConvertStateToProof(context.Background(), "foo.json") - require.ErrorIs(t, err, executor.err) - }) - - t.Run("InvalidOutput", func(t *testing.T) { - converter, executor := setup(t) - executor.stdOut = "blah blah" - _, _, _, err := converter.ConvertStateToProof(context.Background(), "foo.json") - require.ErrorContains(t, err, "failed to parse state data") - }) -} - -type capturingExecutor struct { - binary string - args []string - - stdOut string - stdErr string - err error -} - -func (c *capturingExecutor) exec(_ context.Context, binary string, args ...string) (string, string, error) { - c.binary = binary - c.args = args - return c.stdOut, c.stdErr, c.err -} diff --git a/op-challenger/game/fault/trace/asterisc/test_data/invalid.json b/op-challenger/game/fault/trace/asterisc/test_data/invalid.json deleted file mode 100644 index 06a76bf5b23..00000000000 --- a/op-challenger/game/fault/trace/asterisc/test_data/invalid.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "preimageKey": 1 -} diff --git a/op-challenger/game/fault/trace/asterisc/test_data/proofs/0.json b/op-challenger/game/fault/trace/asterisc/test_data/proofs/0.json deleted file mode 100644 index e5838ddfc5a..00000000000 --- a/op-challenger/game/fault/trace/asterisc/test_data/proofs/0.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "step": 0, - "pre": "0x03abd5c535c08bae7c4ad48fcae39b65f9c25239f65b4376c58638d262c97381", - "post": "0x034689707b571db46b32c9e433def18e648f4e1fa9e5abd4012e7913031bfc10", - "state-data": "0x354cfaf28a5b60c3f64f22f9f171b64aa067f90c6de6c96f725f44c5cf9f8ac1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080e080000000000000000000000007f0000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "proof-data": "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" -} diff --git a/op-challenger/game/fault/trace/asterisc/test_data/proofs/1.json b/op-challenger/game/fault/trace/asterisc/test_data/proofs/1.json deleted file mode 100644 index 311847daa5a..00000000000 --- a/op-challenger/game/fault/trace/asterisc/test_data/proofs/1.json +++ /dev/null @@ -1,2 +0,0 @@ -{} - diff --git a/op-challenger/game/fault/trace/asterisc/test_data/proofs/2.json b/op-challenger/game/fault/trace/asterisc/test_data/proofs/2.json deleted file mode 100644 index 96f58c8e8cb..00000000000 --- a/op-challenger/game/fault/trace/asterisc/test_data/proofs/2.json +++ /dev/null @@ -1,9 +0,0 @@ -{ - "foo": 0, - "bar": "0x71f9eb93ff904e5c03c3425228ef75766db0c906ad239df9a7a7f0d9c6a89705", - "step": 0, - "pre": "0x03abd5c535c08bae7c4ad48fcae39b65f9c25239f65b4376c58638d262c97381", - "post": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", - "state-data": "0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc", - "proof-data": "0xdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd" -} diff --git a/op-challenger/game/fault/trace/asterisc/test_data/state.json b/op-challenger/game/fault/trace/asterisc/test_data/state.json deleted file mode 100644 index 00dfc2d666c..00000000000 --- a/op-challenger/game/fault/trace/asterisc/test_data/state.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "pc": 0, - "exited": false, - "step": 0, - "witness": "wOSi8Cm62dDmKt1OGwxlLrSznk6zE4ghp7evP1rfrXYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIGCAAAAAAAAAAAAAAAAB/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", - "stateHash": "0x03216fdc4a7bfd4c7160fa946d1bfe451d13ff32da496609fe18355282b910c6" -} diff --git a/op-challenger/game/fault/trace/outputs/output_asterisc.go b/op-challenger/game/fault/trace/outputs/output_asterisc.go deleted file mode 100644 index 10822a5a9ae..00000000000 --- a/op-challenger/game/fault/trace/outputs/output_asterisc.go +++ /dev/null @@ -1,52 +0,0 @@ -package outputs - -import ( - "context" - "fmt" - "path/filepath" - - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/log" - - "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace" - "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/asterisc" - "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-service/eth" -) - -func NewOutputAsteriscTraceAccessor( - logger log.Logger, - m metrics.Metricer, - cfg vm.Config, - vmCfg vm.OracleServerExecutor, - l2Client utils.L2HeaderSource, - prestateProvider types.PrestateProvider, - asteriscPrestate string, - rollupClient OutputRollupClient, - dir string, - l1Head eth.BlockID, - splitDepth types.Depth, - prestateBlock uint64, - poststateBlock uint64, -) (*trace.Accessor, error) { - outputProvider := NewTraceProvider(logger, prestateProvider, rollupClient, l2Client, l1Head, splitDepth, prestateBlock, poststateBlock) - asteriscCreator := func(ctx context.Context, localContext common.Hash, depth types.Depth, agreed utils.Proposal, claimed utils.Proposal) (types.TraceProvider, error) { - logger := logger.New("pre", agreed.OutputRoot, "post", claimed.OutputRoot, "localContext", localContext) - subdir := filepath.Join(dir, localContext.Hex()) - localInputs, err := utils.FetchLocalInputsFromProposals(ctx, l1Head.Hash, l2Client, agreed, claimed) - if err != nil { - return nil, fmt.Errorf("failed to fetch asterisc local inputs: %w", err) - } - provider := asterisc.NewTraceProvider(logger, m.ToTypedVmMetrics(cfg.VmType.String()), cfg, vmCfg, prestateProvider, asteriscPrestate, localInputs, subdir, depth) - return provider, nil - } - - metricsLabel := fmt.Sprintf("outputs_%s_provider", cfg.VmType.String()) - cache := NewProviderCache(m, metricsLabel, asteriscCreator) - selector := split.NewSplitProviderSelector(outputProvider, splitDepth, OutputRootSplitAdapter(outputProvider, cache.GetOrCreate)) - return trace.NewAccessor(selector), nil -} diff --git a/op-challenger/game/fault/trace/vm/executor_test.go b/op-challenger/game/fault/trace/vm/executor_test.go index d6bdf48fedd..d401b2d5b99 100644 --- a/op-challenger/game/fault/trace/vm/executor_test.go +++ b/op-challenger/game/fault/trace/vm/executor_test.go @@ -62,7 +62,7 @@ func TestGenerateProof(t *testing.T) { cfg.DebugInfo = true _, _, args := captureExec(t, dir, cfg, inputs, info, math.MaxUint64, m) // stop-at would need to be one more than the proof step which would overflow back to 0 - // so expect that it will be omitted. We'll ultimately want asterisc to execute until the program exits. + // so expect that it will be omitted. We'll ultimately want the vm to execute until the program exits. require.NotContains(t, args, "--stop-at") validateMetrics(t, m, info, cfg) }) diff --git a/op-challenger/game/types/game_type.go b/op-challenger/game/types/game_type.go index f1f9ed111b0..c39faa0889e 100644 --- a/op-challenger/game/types/game_type.go +++ b/op-challenger/game/types/game_type.go @@ -11,10 +11,10 @@ var ErrUnknownGameType = errors.New("unknown game type") type GameType uint32 const ( - CannonGameType GameType = 0 - PermissionedGameType GameType = 1 - AsteriscGameType GameType = 2 - AsteriscKonaGameType GameType = 3 + CannonGameType GameType = 0 + PermissionedGameType GameType = 1 + // 2 was originally reserved for Asterisc game type but never released. + // 3 was originally reserved for AsteriscKona game type but never released. SuperCannonGameType GameType = 4 SuperPermissionedGameType GameType = 5 OPSuccinctGameType GameType = 6 // Not supported by op-challenger @@ -35,8 +35,6 @@ var SupportedGameTypes = []GameType{ CannonGameType, CannonKonaGameType, PermissionedGameType, - AsteriscGameType, - AsteriscKonaGameType, FastGameType, SuperCannonGameType, SuperCannonKonaGameType, @@ -78,10 +76,6 @@ func (g GameType) String() string { return "cannon" case PermissionedGameType: return "permissioned" - case AsteriscGameType: - return "asterisc" - case AsteriscKonaGameType: - return "asterisc-kona" case SuperCannonGameType: return "super-cannon" case SuperPermissionedGameType: diff --git a/op-challenger/runner/factory.go b/op-challenger/runner/factory.go index 934d322ce57..bf13351f1cc 100644 --- a/op-challenger/runner/factory.go +++ b/op-challenger/runner/factory.go @@ -6,7 +6,6 @@ import ( "net/url" "github.com/ethereum-optimism/optimism/op-challenger/config" - "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/asterisc" "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/cannon" "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/utils" "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/vm" @@ -48,24 +47,6 @@ func createTraceProvider( } prestateProvider := vm.NewPrestateProvider(prestate, stateConverter) return cannon.NewTraceProvider(logger, m, cfg.CannonKona, serverExecutor, prestateProvider, prestate, localInputs, dir, 42), nil - case gameTypes.AsteriscGameType: - serverExecutor := vm.NewOpProgramServerExecutor(logger) - stateConverter := asterisc.NewStateConverter(cfg.Asterisc) - prestate, err := prestateSource.getPrestate(ctx, logger, cfg.AsteriscAbsolutePreStateBaseURL, cfg.AsteriscAbsolutePreState, dir, stateConverter) - if err != nil { - return nil, err - } - prestateProvider := vm.NewPrestateProvider(prestate, stateConverter) - return asterisc.NewTraceProvider(logger, m, cfg.Asterisc, serverExecutor, prestateProvider, prestate, localInputs, dir, 42), nil - case gameTypes.AsteriscKonaGameType: - serverExecutor := vm.NewKonaExecutor() - stateConverter := asterisc.NewStateConverter(cfg.AsteriscKona) - prestate, err := prestateSource.getPrestate(ctx, logger, cfg.AsteriscKonaAbsolutePreStateBaseURL, cfg.AsteriscKonaAbsolutePreState, dir, stateConverter) - if err != nil { - return nil, err - } - prestateProvider := vm.NewPrestateProvider(prestate, stateConverter) - return asterisc.NewTraceProvider(logger, m, cfg.AsteriscKona, serverExecutor, prestateProvider, prestate, localInputs, dir, 42), nil } return nil, errors.New("invalid game type") } diff --git a/op-dispute-mon/mon/extract/caller.go b/op-dispute-mon/mon/extract/caller.go index 6de5063efc5..4aa3aa96618 100644 --- a/op-dispute-mon/mon/extract/caller.go +++ b/op-dispute-mon/mon/extract/caller.go @@ -54,10 +54,8 @@ func (g *GameCallerCreator) CreateContract(ctx context.Context, game gameTypes.G case gameTypes.CannonGameType, gameTypes.PermissionedGameType, gameTypes.CannonKonaGameType, - gameTypes.AsteriscGameType, gameTypes.AlphabetGameType, gameTypes.FastGameType, - gameTypes.AsteriscKonaGameType, gameTypes.SuperCannonGameType, gameTypes.SuperPermissionedGameType, gameTypes.SuperCannonKonaGameType: diff --git a/op-dispute-mon/mon/extract/caller_test.go b/op-dispute-mon/mon/extract/caller_test.go index 32a8e51bd7a..ff5e42daadd 100644 --- a/op-dispute-mon/mon/extract/caller_test.go +++ b/op-dispute-mon/mon/extract/caller_test.go @@ -38,10 +38,6 @@ func TestMetadataCreator_CreateContract(t *testing.T) { name: "validCannonKonaGameType", game: types.GameMetadata{GameType: uint32(types.CannonKonaGameType), Proxy: fdgAddr}, }, - { - name: "validAsteriscGameType", - game: types.GameMetadata{GameType: uint32(types.AsteriscGameType), Proxy: fdgAddr}, - }, { name: "validAlphabetGameType", game: types.GameMetadata{GameType: uint32(types.AlphabetGameType), Proxy: fdgAddr}, @@ -50,10 +46,6 @@ func TestMetadataCreator_CreateContract(t *testing.T) { name: "validFastGameType", game: types.GameMetadata{GameType: uint32(types.FastGameType), Proxy: fdgAddr}, }, - { - name: "validAsteriscKonaGameType", - game: types.GameMetadata{GameType: uint32(types.AsteriscKonaGameType), Proxy: fdgAddr}, - }, { name: "validSuperCannonGameType", game: types.GameMetadata{GameType: uint32(types.SuperCannonGameType), Proxy: fdgAddr}, diff --git a/op-dispute-mon/mon/types/types.go b/op-dispute-mon/mon/types/types.go index 753e2291767..0077d562648 100644 --- a/op-dispute-mon/mon/types/types.go +++ b/op-dispute-mon/mon/types/types.go @@ -16,8 +16,6 @@ import ( var outputRootGameTypes = []types.GameType{ types.CannonGameType, types.PermissionedGameType, - types.AsteriscGameType, - types.AsteriscKonaGameType, types.OPSuccinctGameType, types.CannonKonaGameType, types.OptimisticZKGameType, From a2f56ffb16725f7315c5fa4d31a00ce412863297 Mon Sep 17 00:00:00 2001 From: Adrian Sutton Date: Mon, 22 Dec 2025 14:15:11 +1000 Subject: [PATCH 3/4] op-challenger: Restore the game type definitions. --- op-challenger/game/types/game_type.go | 30 ++++++++++++++++----------- 1 file changed, 18 insertions(+), 12 deletions(-) diff --git a/op-challenger/game/types/game_type.go b/op-challenger/game/types/game_type.go index c39faa0889e..55a50df9b20 100644 --- a/op-challenger/game/types/game_type.go +++ b/op-challenger/game/types/game_type.go @@ -11,21 +11,21 @@ var ErrUnknownGameType = errors.New("unknown game type") type GameType uint32 const ( - CannonGameType GameType = 0 - PermissionedGameType GameType = 1 - // 2 was originally reserved for Asterisc game type but never released. - // 3 was originally reserved for AsteriscKona game type but never released. + CannonGameType GameType = 0 + PermissionedGameType GameType = 1 + AsteriscGameType GameType = 2 // Not supported by op-challenger + AsteriscKonaGameType GameType = 3 // Not supported by op-challenger SuperCannonGameType GameType = 4 SuperPermissionedGameType GameType = 5 OPSuccinctGameType GameType = 6 // Not supported by op-challenger - // 7 was originally reserved for SuperAsteriscKona game type but never released. - CannonKonaGameType GameType = 8 - SuperCannonKonaGameType GameType = 9 - OptimisticZKGameType GameType = 10 - FastGameType GameType = 254 - AlphabetGameType GameType = 255 - KailuaGameType GameType = 1337 // Not supported by op-challenger - UnknownGameType GameType = math.MaxUint32 // Not supported by op-challenger + SuperAsteriscKonaGameType GameType = 7 // Not supported by op-challenger + CannonKonaGameType GameType = 8 + SuperCannonKonaGameType GameType = 9 + OptimisticZKGameType GameType = 10 + FastGameType GameType = 254 + AlphabetGameType GameType = 255 + KailuaGameType GameType = 1337 // Not supported by op-challenger + UnknownGameType GameType = math.MaxUint32 // Not supported by op-challenger ) // SupportedGameTypes is the list of game types that are supported by op-challenger. @@ -76,12 +76,18 @@ func (g GameType) String() string { return "cannon" case PermissionedGameType: return "permissioned" + case AsteriscGameType: + return "asterisc" + case AsteriscKonaGameType: + return "asterisc-kona" case SuperCannonGameType: return "super-cannon" case SuperPermissionedGameType: return "super-permissioned" case OPSuccinctGameType: return "op-succinct" + case SuperAsteriscKonaGameType: + return "super-asterisc-kona" case CannonKonaGameType: return "cannon-kona" case SuperCannonKonaGameType: From 67d1fbcd10bcc9ae3543ac82cc4ee2ede8ade2ca Mon Sep 17 00:00:00 2001 From: Adrian Sutton Date: Mon, 22 Dec 2025 17:19:14 +1000 Subject: [PATCH 4/4] Restore categorisation --- op-dispute-mon/mon/types/types.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/op-dispute-mon/mon/types/types.go b/op-dispute-mon/mon/types/types.go index 0077d562648..7b1874516c8 100644 --- a/op-dispute-mon/mon/types/types.go +++ b/op-dispute-mon/mon/types/types.go @@ -16,6 +16,8 @@ import ( var outputRootGameTypes = []types.GameType{ types.CannonGameType, types.PermissionedGameType, + types.AsteriscGameType, + types.AsteriscKonaGameType, types.OPSuccinctGameType, types.CannonKonaGameType, types.OptimisticZKGameType, @@ -27,6 +29,7 @@ var outputRootGameTypes = []types.GameType{ var superRootGameTypes = []types.GameType{ types.SuperCannonGameType, types.SuperPermissionedGameType, + types.SuperAsteriscKonaGameType, types.SuperCannonKonaGameType, }