Skip to content

op-challenger: Add config option to set dependency set config #14666

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
ajsutton merged 2 commits into from
Mar 6, 2025
Merged

op-challenger: Add config option to set dependency set config #14666

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
99c40d6
op-challenger: Add config option to set dependency set config
ajsutton Mar 6, 2025
5270faf
Fix expected error message
ajsutton Mar 6, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
279 changes: 204 additions & 75 deletions op-challenger/cmd/main_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -620,6 +620,196 @@ func TestAlphabetRequiredArgs(t *testing.T) {
})
}

func TestCannonCustomConfigArgs(t *testing.T) {
for _, traceType := range []types.TraceType{types.TraceTypeCannon, types.TraceTypePermissioned} {
traceType := traceType

t.Run(fmt.Sprintf("TestRequireEitherCannonNetworkOrRollupAndGenesis-%v", traceType), func(t *testing.T) {
verifyArgsInvalid(
t,
"flag network or rollup-config/cannon-rollup-config and l2-genesis/cannon-l2-genesis is required",
addRequiredArgsExcept(traceType, "--network"))
verifyArgsInvalid(
t,
"flag network or rollup-config/cannon-rollup-config and l2-genesis/cannon-l2-genesis is required",
addRequiredArgsExcept(traceType, "--network", "--cannon-rollup-config=rollup.json"))
verifyArgsInvalid(
t,
"flag network or rollup-config/cannon-rollup-config and l2-genesis/cannon-l2-genesis is required",
addRequiredArgsExcept(traceType, "--network", "--cannon-l2-genesis=gensis.json"))
})

t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) {
verifyArgsInvalid(
t,
"flag network can not be used with cannon-rollup-config, l2-genesis or cannon-l2-custom",
addRequiredArgs(traceType, "--cannon-rollup-config=rollup.json"))
})

t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) {
args := requiredArgs(traceType)
delete(args, "--network")
delete(args, "--game-factory-address")
args["--network"] = network
args["--cannon-rollup-config"] = "rollup.json"
args["--cannon-l2-genesis"] = "gensis.json"
args["--cannon-l2-custom"] = "true"
verifyArgsInvalid(
t,
"flag network can not be used with cannon-rollup-config, cannon-l2-genesis or cannon-l2-custom",
toArgList(args))
})

t.Run(fmt.Sprintf("TestNetwork-%v", traceType), func(t *testing.T) {
t.Run("NotRequiredWhenRollupAndGenesIsSpecified", func(t *testing.T) {
configForArgs(t, addRequiredArgsExcept(traceType, "--network",
"--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json"))
})

t.Run("Valid", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--network", testNetwork))
require.Equal(t, []string{testNetwork}, cfg.Cannon.Networks)
})
})

t.Run(fmt.Sprintf("TestSetCannonL2ChainId-%v", traceType), func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network",
"--cannon-rollup-config=rollup.json",
"--cannon-l2-genesis=genesis.json",
"--cannon-l2-custom"))
require.True(t, cfg.Cannon.L2Custom)
})

t.Run(fmt.Sprintf("TestCannonRollupConfig-%v", traceType), func(t *testing.T) {
t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
configForArgs(t, addRequiredArgsExcept(types.TraceTypeAlphabet, "--cannon-rollup-config"))
})

t.Run("Valid", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json"))
require.Equal(t, []string{"rollup.json"}, cfg.Cannon.RollupConfigPaths)
})
})

t.Run(fmt.Sprintf("TestCannonL2Genesis-%v", traceType), func(t *testing.T) {
t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
configForArgs(t, addRequiredArgsExcept(types.TraceTypeAlphabet, "--cannon-l2-genesis"))
})

t.Run("Valid", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json"))
require.Equal(t, []string{"genesis.json"}, cfg.Cannon.L2GenesisPaths)
})
})
}
}

func TestSuperCannonCustomConfigArgs(t *testing.T) {
for _, traceType := range []types.TraceType{types.TraceTypeSuperCannon, types.TraceTypeSuperPermissioned} {
traceType := traceType

t.Run(fmt.Sprintf("TestRequireEitherCannonNetworkOrRollupAndGenesisAndDepset-%v", traceType), func(t *testing.T) {
expectedErrorMessage := "flag network or rollup-config/cannon-rollup-config, l2-genesis/cannon-l2-genesis and depset-config/cannon-depset-config is required"
// Missing all
verifyArgsInvalid(
t,
expectedErrorMessage,
addRequiredArgsExcept(traceType, "--network"))
// Missing l2-genesis
verifyArgsInvalid(
t,
expectedErrorMessage,
addRequiredArgsExcept(traceType, "--network", "--cannon-rollup-config=rollup.json", "--cannon-depset-config=depset.json"))
// Missing rollup-config
verifyArgsInvalid(
t,
expectedErrorMessage,
addRequiredArgsExcept(traceType, "--network", "--cannon-l2-genesis=gensis.json", "--cannon-depset-config=depset.json"))
// Missing depset-config
verifyArgsInvalid(
t,
expectedErrorMessage,
addRequiredArgsExcept(traceType, "--network", "--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=gensis.json"))
})

t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) {
verifyArgsInvalid(
t,
"flag network can not be used with cannon-rollup-config, l2-genesis or cannon-l2-custom",
addRequiredArgs(traceType, "--cannon-rollup-config=rollup.json"))
})

t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) {
args := requiredArgs(traceType)
delete(args, "--network")
delete(args, "--game-factory-address")
args["--network"] = network
args["--cannon-rollup-config"] = "rollup.json"
args["--cannon-l2-genesis"] = "gensis.json"
args["--cannon-l2-custom"] = "true"
verifyArgsInvalid(
t,
"flag network can not be used with cannon-rollup-config, cannon-l2-genesis or cannon-l2-custom",
toArgList(args))
})

t.Run(fmt.Sprintf("TestNetwork-%v", traceType), func(t *testing.T) {
t.Run("NotRequiredWhenRollupGenesisAndDepsetIsSpecified", func(t *testing.T) {
configForArgs(t, addRequiredArgsExcept(traceType, "--network",
"--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json", "--cannon-depset-config=depset.json"))
})

t.Run("Valid", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--network", testNetwork))
require.Equal(t, []string{testNetwork}, cfg.Cannon.Networks)
})
})

t.Run(fmt.Sprintf("TestSetCannonL2ChainId-%v", traceType), func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network",
"--cannon-rollup-config=rollup.json",
"--cannon-l2-genesis=genesis.json",
"--cannon-depset-config=depset.json",
"--cannon-l2-custom"))
require.True(t, cfg.Cannon.L2Custom)
})

t.Run(fmt.Sprintf("TestCannonRollupConfig-%v", traceType), func(t *testing.T) {
t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
configForArgs(t, addRequiredArgsExcept(types.TraceTypeAlphabet, "--cannon-rollup-config"))
})

t.Run("Valid", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network",
"--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json", "--cannon-depset-config=depset.json"))
require.Equal(t, []string{"rollup.json"}, cfg.Cannon.RollupConfigPaths)
})
})

t.Run(fmt.Sprintf("TestCannonL2Genesis-%v", traceType), func(t *testing.T) {
t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
configForArgs(t, addRequiredArgsExcept(types.TraceTypeAlphabet, "--cannon-l2-genesis"))
})

t.Run("Valid", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json", "--cannon-depset-config=depset.json"))
require.Equal(t, []string{"genesis.json"}, cfg.Cannon.L2GenesisPaths)
})
})

t.Run(fmt.Sprintf("TestCannonDepsetConfig-%v", traceType), func(t *testing.T) {
t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
configForArgs(t, addRequiredArgsExcept(types.TraceTypeAlphabet, "--cannon-depset-config"))
})

t.Run("Valid", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json", "--cannon-depset-config=depset.json"))
require.Equal(t, "depset.json", cfg.Cannon.DepsetConfigPath)
})
})
}
}

func TestCannonRequiredArgs(t *testing.T) {
for _, traceType := range []types.TraceType{types.TraceTypeCannon, types.TraceTypePermissioned, types.TraceTypeSuperCannon, types.TraceTypeSuperPermissioned} {
traceType := traceType
Expand Down Expand Up @@ -756,84 +946,23 @@ func TestCannonRequiredArgs(t *testing.T) {
addRequiredArgs(traceType, "--cannon-info-freq=abc"))
})
})
}
}

t.Run(fmt.Sprintf("TestRequireEitherCannonNetworkOrRollupAndGenesis-%v", traceType), func(t *testing.T) {
verifyArgsInvalid(
t,
"flag network or rollup-config/cannon-rollup-config and l2-genesis/cannon-l2-genesis is required",
addRequiredArgsExcept(traceType, "--network"))
verifyArgsInvalid(
t,
"flag network or rollup-config/cannon-rollup-config and l2-genesis/cannon-l2-genesis is required",
addRequiredArgsExcept(traceType, "--network", "--cannon-rollup-config=rollup.json"))
verifyArgsInvalid(
t,
"flag network or rollup-config/cannon-rollup-config and l2-genesis/cannon-l2-genesis is required",
addRequiredArgsExcept(traceType, "--network", "--cannon-l2-genesis=gensis.json"))
})

t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) {
verifyArgsInvalid(
t,
"flag network can not be used with cannon-rollup-config, l2-genesis or cannon-l2-custom",
addRequiredArgs(traceType, "--cannon-rollup-config=rollup.json"))
})

t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) {
args := requiredArgs(traceType)
delete(args, "--network")
delete(args, "--game-factory-address")
args["--network"] = network
args["--cannon-rollup-config"] = "rollup.json"
args["--cannon-l2-genesis"] = "gensis.json"
args["--cannon-l2-custom"] = "true"
verifyArgsInvalid(
t,
"flag network can not be used with cannon-rollup-config, cannon-l2-genesis or cannon-l2-custom",
toArgList(args))
})

t.Run(fmt.Sprintf("TestNetwork-%v", traceType), func(t *testing.T) {
t.Run("NotRequiredWhenRollupAndGenesIsSpecified", func(t *testing.T) {
configForArgs(t, addRequiredArgsExcept(traceType, "--network",
"--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json"))
})

t.Run("Valid", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--network", testNetwork))
require.Equal(t, []string{testNetwork}, cfg.Cannon.Networks)
})
})

t.Run(fmt.Sprintf("TestSetCannonL2ChainId-%v", traceType), func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network",
"--cannon-rollup-config=rollup.json",
"--cannon-l2-genesis=genesis.json",
"--cannon-l2-custom"))
require.True(t, cfg.Cannon.L2Custom)
})

t.Run(fmt.Sprintf("TestCannonRollupConfig-%v", traceType), func(t *testing.T) {
t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
configForArgs(t, addRequiredArgsExcept(types.TraceTypeAlphabet, "--cannon-rollup-config"))
})

t.Run("Valid", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json"))
require.Equal(t, []string{"rollup.json"}, cfg.Cannon.RollupConfigPaths)
})
})

t.Run(fmt.Sprintf("TestCannonL2Genesis-%v", traceType), func(t *testing.T) {
t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
configForArgs(t, addRequiredArgsExcept(types.TraceTypeAlphabet, "--cannon-l2-genesis"))
func TestDepsetConfig(t *testing.T) {
for _, traceType := range types.TraceTypes {
if traceType == types.TraceTypeSuperCannon || traceType == types.TraceTypeSuperPermissioned {
t.Run("Required-"+traceType.String(), func(t *testing.T) {
verifyArgsInvalid(t,
"flag network or rollup-config/cannon-rollup-config, l2-genesis/cannon-l2-genesis and depset-config/cannon-depset-config is required",
addRequiredArgsExcept(traceType, "--network", "--rollup-config=rollup.json", "--l2-genesis=genesis.json"))
})

t.Run("Valid", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json"))
require.Equal(t, []string{"genesis.json"}, cfg.Cannon.L2GenesisPaths)
} else {
t.Run("NotRequired-"+traceType.String(), func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--rollup-config=rollup.json", "--l2-genesis=genesis.json"))
require.Equal(t, "", cfg.Cannon.DepsetConfigPath)
})
})
}
}
}

Expand Down
5 changes: 5 additions & 0 deletions op-challenger/config/config.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -27,6 +27,7 @@ var (
ErrMissingGameFactoryAddress = errors.New("missing game factory address")
ErrMissingCannonSnapshotFreq = errors.New("missing cannon snapshot freq")
ErrMissingCannonInfoFreq = errors.New("missing cannon info freq")
ErrMissingDepsetConfig = errors.New("missing network or depset config path")

ErrMissingRollupRpc = errors.New("missing rollup rpc url")
ErrMissingSupervisorRpc = errors.New("missing supervisor rpc url")
Expand Down Expand Up @@ -189,6 +190,10 @@ func (c Config) Check() error {
if c.SupervisorRPC == "" {
return ErrMissingSupervisorRpc
}

if len(c.Cannon.Networks) == 0 && c.Cannon.DepsetConfigPath == "" {
return ErrMissingDepsetConfig
}
if err := c.validateBaseCannonOptions(); err != nil {
return err
}
Expand Down
39 changes: 37 additions & 2 deletions op-challenger/config/config_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -44,10 +44,17 @@ var (
validAsteriscKonaAbsolutePreStateBaseURL, _ = url.Parse("http://localhost/bar/")
)

var cannonTraceTypes = []types.TraceType{types.TraceTypeCannon, types.TraceTypePermissioned, types.TraceTypeSuperCannon, types.TraceTypeSuperPermissioned}
var singleCannonTraceTypes = []types.TraceType{types.TraceTypeCannon, types.TraceTypePermissioned}
var superCannonTraceTypes = []types.TraceType{types.TraceTypeSuperCannon, types.TraceTypeSuperPermissioned}
var allCannonTraceTypes []types.TraceType
var asteriscTraceTypes = []types.TraceType{types.TraceTypeAsterisc}
var asteriscKonaTraceTypes = []types.TraceType{types.TraceTypeAsteriscKona}

func init() {
allCannonTraceTypes = append(allCannonTraceTypes, singleCannonTraceTypes...)
allCannonTraceTypes = append(allCannonTraceTypes, superCannonTraceTypes...)
}

func ensureExists(path string) error {
_, err := os.Stat(path)
if err == nil {
Expand Down Expand Up @@ -178,7 +185,7 @@ func TestGameAllowlistNotRequired(t *testing.T) {
}

func TestCannonRequiredArgs(t *testing.T) {
for _, traceType := range cannonTraceTypes {
for _, traceType := range allCannonTraceTypes {
traceType := traceType

t.Run(fmt.Sprintf("TestCannonBinRequired-%v", traceType), func(t *testing.T) {
Expand Down Expand Up @@ -249,6 +256,7 @@ func TestCannonRequiredArgs(t *testing.T) {
cfg.Cannon.Networks = nil
cfg.Cannon.RollupConfigPaths = nil
cfg.Cannon.L2GenesisPaths = []string{"genesis.json"}
cfg.Cannon.DepsetConfigPath = "foo.json"
require.ErrorIs(t, cfg.Check(), vm.ErrMissingRollupConfig)
})

Expand All @@ -257,6 +265,7 @@ func TestCannonRequiredArgs(t *testing.T) {
cfg.Cannon.Networks = nil
cfg.Cannon.RollupConfigPaths = []string{"foo.json"}
cfg.Cannon.L2GenesisPaths = nil
cfg.Cannon.DepsetConfigPath = "foo.json"
require.ErrorIs(t, cfg.Check(), vm.ErrMissingL2Genesis)
})

Expand Down Expand Up @@ -305,6 +314,32 @@ func TestCannonRequiredArgs(t *testing.T) {
}
}

func TestDepsetConfig(t *testing.T) {
for _, traceType := range superCannonTraceTypes {
traceType := traceType
t.Run(fmt.Sprintf("TestCannonNetworkOrDepsetConfigRequired-%v", traceType), func(t *testing.T) {
cfg := validConfig(t, traceType)
cfg.Cannon.Networks = nil
cfg.Cannon.RollupConfigPaths = []string{"foo.json"}
cfg.Cannon.L2GenesisPaths = []string{"genesis.json"}
cfg.Cannon.DepsetConfigPath = ""
require.ErrorIs(t, cfg.Check(), ErrMissingDepsetConfig)
})
}

for _, traceType := range singleCannonTraceTypes {
traceType := traceType
t.Run(fmt.Sprintf("TestDepsetConfigNotRequired-%v", traceType), func(t *testing.T) {
cfg := validConfig(t, traceType)
cfg.Cannon.Networks = nil
cfg.Cannon.RollupConfigPaths = []string{"foo.json"}
cfg.Cannon.L2GenesisPaths = []string{"genesis.json"}
cfg.Cannon.DepsetConfigPath = ""
require.NoError(t, cfg.Check())
})
}
}

func TestAsteriscRequiredArgs(t *testing.T) {
for _, traceType := range asteriscTraceTypes {
traceType := traceType
Expand Down
Loading