Skip to content

N
nebula
Commit 6f0d98c5 authored by Adrian Sutton's avatar Adrian Sutton Committed by GitHub
Browse files
Options

op-challenger: Simplify flags and validation (#13756) 

* op-challenger: Remove duplicate validation for vm.Config instances

* op-challenger: Remove cannon-network and asterisc-network flags.

* op-challenger: Use vm flags for rollup-config and l2-genesis

* op-challenger: Deduplicate prestates URL parsing

* op-challenger: Remove legacy --cannon-l2 flag

* op-challenger: Show generic and trace type specific names in error messages.

* Update expected error messages.
parent 107948cc
Show whitespace changes
Inline Side-by-side
Showing with 218 additions and 402 deletions
op-challenger/cmd/main_test.go
View file @ 6f0d98c5
...@@ -23,7 +23,7 @@ var ( ...@@ -23,7 +23,7 @@ var (
l1EthRpc = "http://example.com:8545" l1EthRpc = "http://example.com:8545"
l1Beacon = "http://example.com:9000" l1Beacon = "http://example.com:9000"
gameFactoryAddressValue = "0xbb00000000000000000000000000000000000000" gameFactoryAddressValue = "0xbb00000000000000000000000000000000000000"
cannonNetwork = "op-mainnet" network = "op-mainnet"
testNetwork = "op-sepolia" testNetwork = "op-sepolia"
l2EthRpc = "http://example.com:9545" l2EthRpc = "http://example.com:9545"
cannonBin = "./bin/cannon" cannonBin = "./bin/cannon"
...@@ -31,7 +31,6 @@ var ( ...@@ -31,7 +31,6 @@ var (
cannonPreState = "./pre.json" cannonPreState = "./pre.json"
datadir = "./test_data" datadir = "./test_data"
rollupRpc = "http://example.com:8555" rollupRpc = "http://example.com:8555"
asteriscNetwork = "op-mainnet"
asteriscBin = "./bin/asterisc" asteriscBin = "./bin/asterisc"
asteriscServer = "./bin/op-program" asteriscServer = "./bin/op-program"
asteriscPreState = "./pre.json" asteriscPreState = "./pre.json"
...@@ -294,7 +293,7 @@ func TestAsteriscOpProgramRequiredArgs(t *testing.T) { ...@@ -294,7 +293,7 @@ func TestAsteriscOpProgramRequiredArgs(t *testing.T) {
}) })
t.Run("Required", func(t *testing.T) { t.Run("Required", func(t *testing.T) {
verifyArgsInvalid(t, "flag prestates-url or asterisc-prestate is required", addRequiredArgsExcept(traceType, "--asterisc-prestate")) verifyArgsInvalid(t, "flag prestates-url/asterisc-prestates-url or asterisc-prestate is required", addRequiredArgsExcept(traceType, "--asterisc-prestate"))
}) })
t.Run("Valid", func(t *testing.T) { t.Run("Valid", func(t *testing.T) {
...@@ -319,7 +318,7 @@ func TestAsteriscOpProgramRequiredArgs(t *testing.T) { ...@@ -319,7 +318,7 @@ func TestAsteriscOpProgramRequiredArgs(t *testing.T) {
}) })
t.Run("RequiredIfAsteriscPrestatesBaseURLNotSet", func(t *testing.T) { t.Run("RequiredIfAsteriscPrestatesBaseURLNotSet", func(t *testing.T) {
verifyArgsInvalid(t, "flag prestates-url or asterisc-prestate is required", addRequiredArgsExceptArr(traceType, allPrestateOptions)) verifyArgsInvalid(t, "flag prestates-url/asterisc-prestates-url or asterisc-prestate is required", addRequiredArgsExceptArr(traceType, allPrestateOptions))
}) })
t.Run("Invalid", func(t *testing.T) { t.Run("Invalid", func(t *testing.T) {
...@@ -338,7 +337,7 @@ func TestAsteriscOpProgramRequiredArgs(t *testing.T) { ...@@ -338,7 +337,7 @@ func TestAsteriscOpProgramRequiredArgs(t *testing.T) {
}) })
t.Run("Required", func(t *testing.T) { t.Run("Required", func(t *testing.T) {
verifyArgsInvalid(t, "flag prestates-url or asterisc-prestate is required", addRequiredArgsExcept(traceType, "--asterisc-prestate")) verifyArgsInvalid(t, "flag prestates-url/asterisc-prestates-url or asterisc-prestate is required", addRequiredArgsExcept(traceType, "--asterisc-prestate"))
}) })
t.Run("Valid", func(t *testing.T) { t.Run("Valid", func(t *testing.T) {
...@@ -371,7 +370,7 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) { ...@@ -371,7 +370,7 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) {
}) })
t.Run("Required", func(t *testing.T) { t.Run("Required", func(t *testing.T) {
verifyArgsInvalid(t, "flag prestates-url or asterisc-kona-prestate is required", addRequiredArgsExcept(traceType, "--asterisc-kona-prestate")) verifyArgsInvalid(t, "flag prestates-url/asterisc-kona-prestates-url or asterisc-kona-prestate is required", addRequiredArgsExcept(traceType, "--asterisc-kona-prestate"))
}) })
t.Run("Valid", func(t *testing.T) { t.Run("Valid", func(t *testing.T) {
...@@ -386,7 +385,7 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) { ...@@ -386,7 +385,7 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) {
}) })
t.Run("Required", func(t *testing.T) { t.Run("Required", func(t *testing.T) {
verifyArgsInvalid(t, "flag prestates-url or asterisc-kona-prestate is required", addRequiredArgsExcept(traceType, "--asterisc-kona-prestate")) verifyArgsInvalid(t, "flag prestates-url/asterisc-kona-prestates-url or asterisc-kona-prestate is required", addRequiredArgsExcept(traceType, "--asterisc-kona-prestate"))
}) })
t.Run("Valid", func(t *testing.T) { t.Run("Valid", func(t *testing.T) {
...@@ -411,7 +410,7 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) { ...@@ -411,7 +410,7 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) {
}) })
t.Run("RequiredIfAsteriscKonaPrestatesBaseURLNotSet", func(t *testing.T) { t.Run("RequiredIfAsteriscKonaPrestatesBaseURLNotSet", func(t *testing.T) {
verifyArgsInvalid(t, "flag prestates-url or asterisc-kona-prestate is required", addRequiredArgsExceptArr(traceType, allPrestateOptions)) verifyArgsInvalid(t, "flag prestates-url/asterisc-kona-prestates-url or asterisc-kona-prestate is required", addRequiredArgsExceptArr(traceType, allPrestateOptions))
}) })
t.Run("Invalid", func(t *testing.T) { t.Run("Invalid", func(t *testing.T) {
...@@ -448,19 +447,10 @@ func TestAsteriscBaseRequiredArgs(t *testing.T) { ...@@ -448,19 +447,10 @@ func TestAsteriscBaseRequiredArgs(t *testing.T) {
verifyArgsInvalid(t, "flag l2-eth-rpc is required", addRequiredArgsExcept(traceType, "--l2-eth-rpc")) verifyArgsInvalid(t, "flag l2-eth-rpc is required", addRequiredArgsExcept(traceType, "--l2-eth-rpc"))
}) })
t.Run("ValidLegacy", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--l2-eth-rpc", fmt.Sprintf("--cannon-l2=%s", l2EthRpc)))
require.Equal(t, l2EthRpc, cfg.L2Rpc)
})
t.Run("Valid", func(t *testing.T) { t.Run("Valid", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgs(traceType)) cfg := configForArgs(t, addRequiredArgs(traceType))
require.Equal(t, l2EthRpc, cfg.L2Rpc) require.Equal(t, l2EthRpc, cfg.L2Rpc)
}) })
t.Run("InvalidUsingBothFlags", func(t *testing.T) {
verifyArgsInvalid(t, "flag cannon-l2 and l2-eth-rpc must not be both set", addRequiredArgsExcept(traceType, "", fmt.Sprintf("--cannon-l2=%s", l2EthRpc)))
})
}) })
t.Run(fmt.Sprintf("TestAsteriscSnapshotFreq-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestAsteriscSnapshotFreq-%v", traceType), func(t *testing.T) {
...@@ -497,68 +487,49 @@ func TestAsteriscBaseRequiredArgs(t *testing.T) { ...@@ -497,68 +487,49 @@ func TestAsteriscBaseRequiredArgs(t *testing.T) {
}) })
}) })
t.Run(fmt.Sprintf("TestRequireEitherAsteriscNetworkOrRollupAndGenesis-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestRequireEitherNetworkOrRollupAndGenesis-%v", traceType), func(t *testing.T) {
verifyArgsInvalid( verifyArgsInvalid(
t, t,
"flag asterisc-network, network or asterisc-rollup-config and asterisc-l2-genesis is required", fmt.Sprintf("flag network or rollup-config/%s-rollup-config and l2-genesis/%s-l2-genesis is required", traceType, traceType),
addRequiredArgsExcept(traceType, "--asterisc-network")) addRequiredArgsExcept(traceType, "--network"))
verifyArgsInvalid( verifyArgsInvalid(
t, t,
"flag asterisc-network, network or asterisc-rollup-config and asterisc-l2-genesis is required", fmt.Sprintf("flag network or rollup-config/%s-rollup-config and l2-genesis/%s-l2-genesis is required", traceType, traceType),
addRequiredArgsExcept(traceType, "--asterisc-network", "--asterisc-rollup-config=rollup.json")) addRequiredArgsExcept(traceType, "--network", "--rollup-config=rollup.json"))
verifyArgsInvalid(
t,
"flag asterisc-network, network or asterisc-rollup-config and asterisc-l2-genesis is required",
addRequiredArgsExcept(traceType, "--asterisc-network", "--asterisc-l2-genesis=gensis.json"))
})
t.Run(fmt.Sprintf("TestMustNotSpecifyAsteriscNetworkAndRollup-%v", traceType), func(t *testing.T) {
verifyArgsInvalid( verifyArgsInvalid(
t, t,
"flag asterisc-network can not be used with asterisc-rollup-config and asterisc-l2-genesis", fmt.Sprintf("flag network or rollup-config/%s-rollup-config and l2-genesis/%s-l2-genesis is required", traceType, traceType),
addRequiredArgsExcept(traceType, "--asterisc-network", addRequiredArgsExcept(traceType, "--network", "--l2-genesis=gensis.json"))
"--asterisc-network", asteriscNetwork, "--asterisc-rollup-config=rollup.json"))
}) })
t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) {
args := requiredArgs(traceType)
delete(args, "--asterisc-network")
delete(args, "--game-factory-address")
args["--network"] = asteriscNetwork
args["--asterisc-rollup-config"] = "rollup.json"
args["--asterisc-l2-genesis"] = "gensis.json"
verifyArgsInvalid( verifyArgsInvalid(
t, t,
"flag network can not be used with asterisc-rollup-config and asterisc-l2-genesis", "flag network can not be used with rollup-config and l2-genesis",
toArgList(args)) addRequiredArgs(traceType, "--rollup-config=rollup.json"))
}) })
t.Run(fmt.Sprintf("TestAsteriscNetwork-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestNetwork-%v", traceType), func(t *testing.T) {
t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) { t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
configForArgs(t, addRequiredArgsExcept(types.TraceTypeAlphabet, "--asterisc-network")) configForArgs(t, addRequiredArgsExcept(types.TraceTypeAlphabet, "--network"))
}) })
t.Run("NotRequiredWhenRollupAndGenesIsSpecified", func(t *testing.T) { t.Run("NotRequiredWhenRollupAndGenesisSpecified", func(t *testing.T) {
configForArgs(t, addRequiredArgsExcept(traceType, "--asterisc-network", configForArgs(t, addRequiredArgsExcept(traceType, "--network",
"--asterisc-rollup-config=rollup.json", "--asterisc-l2-genesis=genesis.json")) "--rollup-config=rollup.json", "--l2-genesis=genesis.json"))
}) })
t.Run("NotRequiredWhenNetworkSpecified", func(t *testing.T) { t.Run("NotRequiredWhenNetworkSpecified", func(t *testing.T) {
args := requiredArgs(traceType) args := requiredArgs(traceType)
delete(args, "--asterisc-network") delete(args, "--network")
delete(args, "--game-factory-address") delete(args, "--game-factory-address")
args["--network"] = "op-sepolia" args["--network"] = "op-sepolia"
cfg := configForArgs(t, toArgList(args)) cfg := configForArgs(t, toArgList(args))
require.Equal(t, "op-sepolia", cfg.Asterisc.Network) require.Equal(t, "op-sepolia", cfg.Asterisc.Network)
}) })
t.Run("MustNotSpecifyNetworkAndAsteriscNetwork", func(t *testing.T) {
verifyArgsInvalid(t, "flag asterisc-network can not be used with network",
addRequiredArgsExcept(traceType, "--game-factory-address", "--network", "op-sepolia"))
})
t.Run("Valid", func(t *testing.T) { t.Run("Valid", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--asterisc-network", "--asterisc-network", testNetwork)) cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--network", testNetwork))
require.Equal(t, testNetwork, cfg.Asterisc.Network) require.Equal(t, testNetwork, cfg.Asterisc.Network)
}) })
}) })
...@@ -569,18 +540,18 @@ func TestAsteriscBaseRequiredArgs(t *testing.T) { ...@@ -569,18 +540,18 @@ func TestAsteriscBaseRequiredArgs(t *testing.T) {
}) })
t.Run("Valid", func(t *testing.T) { t.Run("Valid", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--asterisc-network", "--asterisc-rollup-config=rollup.json", "--asterisc-l2-genesis=genesis.json")) cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--rollup-config=rollup.json", "--l2-genesis=genesis.json"))
require.Equal(t, "rollup.json", cfg.Asterisc.RollupConfigPath) require.Equal(t, "rollup.json", cfg.Asterisc.RollupConfigPath)
}) })
}) })
t.Run(fmt.Sprintf("TestAsteriscL2Genesis-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestL2Genesis-%v", traceType), func(t *testing.T) {
t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) { t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
configForArgs(t, addRequiredArgsExcept(types.TraceTypeAlphabet, "--asterisc-l2-genesis")) configForArgs(t, addRequiredArgsExcept(types.TraceTypeAlphabet, "--l2-genesis"))
}) })
t.Run("Valid", func(t *testing.T) { t.Run("Valid", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--asterisc-network", "--asterisc-rollup-config=rollup.json", "--asterisc-l2-genesis=genesis.json")) cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--rollup-config=rollup.json", "--l2-genesis=genesis.json"))
require.Equal(t, "genesis.json", cfg.Asterisc.L2GenesisPath) require.Equal(t, "genesis.json", cfg.Asterisc.L2GenesisPath)
}) })
}) })
...@@ -593,11 +564,6 @@ func TestAlphabetRequiredArgs(t *testing.T) { ...@@ -593,11 +564,6 @@ func TestAlphabetRequiredArgs(t *testing.T) {
verifyArgsInvalid(t, "flag l2-eth-rpc is required", addRequiredArgsExcept(types.TraceTypeAlphabet, "--l2-eth-rpc")) verifyArgsInvalid(t, "flag l2-eth-rpc is required", addRequiredArgsExcept(types.TraceTypeAlphabet, "--l2-eth-rpc"))
}) })
t.Run("ValidLegacy", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(types.TraceTypeAlphabet, "--l2-eth-rpc", fmt.Sprintf("--cannon-l2=%s", l2EthRpc)))
require.Equal(t, l2EthRpc, cfg.L2Rpc)
})
t.Run("Valid", func(t *testing.T) { t.Run("Valid", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgs(types.TraceTypeAlphabet)) cfg := configForArgs(t, addRequiredArgs(types.TraceTypeAlphabet))
require.Equal(t, l2EthRpc, cfg.L2Rpc) require.Equal(t, l2EthRpc, cfg.L2Rpc)
...@@ -644,7 +610,7 @@ func TestCannonRequiredArgs(t *testing.T) { ...@@ -644,7 +610,7 @@ func TestCannonRequiredArgs(t *testing.T) {
}) })
t.Run("Required", func(t *testing.T) { t.Run("Required", func(t *testing.T) {
verifyArgsInvalid(t, "flag prestates-url or cannon-prestate is required", addRequiredArgsExcept(traceType, "--cannon-prestate")) verifyArgsInvalid(t, "flag prestates-url/cannon-prestates-url or cannon-prestate is required", addRequiredArgsExcept(traceType, "--cannon-prestate"))
}) })
t.Run("Valid", func(t *testing.T) { t.Run("Valid", func(t *testing.T) {
...@@ -659,7 +625,7 @@ func TestCannonRequiredArgs(t *testing.T) { ...@@ -659,7 +625,7 @@ func TestCannonRequiredArgs(t *testing.T) {
}) })
t.Run("Required", func(t *testing.T) { t.Run("Required", func(t *testing.T) {
verifyArgsInvalid(t, "flag prestates-url or cannon-prestate is required", addRequiredArgsExcept(traceType, "--cannon-prestate")) verifyArgsInvalid(t, "flag prestates-url/cannon-prestates-url or cannon-prestate is required", addRequiredArgsExcept(traceType, "--cannon-prestate"))
}) })
t.Run("Valid", func(t *testing.T) { t.Run("Valid", func(t *testing.T) {
...@@ -684,7 +650,7 @@ func TestCannonRequiredArgs(t *testing.T) { ...@@ -684,7 +650,7 @@ func TestCannonRequiredArgs(t *testing.T) {
}) })
t.Run("RequiredIfCannonPrestatesBaseURLNotSet", func(t *testing.T) { t.Run("RequiredIfCannonPrestatesBaseURLNotSet", func(t *testing.T) {
verifyArgsInvalid(t, "flag prestates-url or cannon-prestate is required", addRequiredArgsExceptArr(traceType, allPrestateOptions)) verifyArgsInvalid(t, "flag prestates-url/cannon-prestates-url or cannon-prestate is required", addRequiredArgsExceptArr(traceType, allPrestateOptions))
}) })
t.Run("Invalid", func(t *testing.T) { t.Run("Invalid", func(t *testing.T) {
...@@ -702,11 +668,6 @@ func TestCannonRequiredArgs(t *testing.T) { ...@@ -702,11 +668,6 @@ func TestCannonRequiredArgs(t *testing.T) {
verifyArgsInvalid(t, "flag l2-eth-rpc is required", addRequiredArgsExcept(traceType, "--l2-eth-rpc")) verifyArgsInvalid(t, "flag l2-eth-rpc is required", addRequiredArgsExcept(traceType, "--l2-eth-rpc"))
}) })
t.Run("ValidLegacy", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--l2-eth-rpc", fmt.Sprintf("--cannon-l2=%s", l2EthRpc)))
require.Equal(t, l2EthRpc, cfg.L2Rpc)
})
t.Run("Valid", func(t *testing.T) { t.Run("Valid", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgs(traceType)) cfg := configForArgs(t, addRequiredArgs(traceType))
require.Equal(t, l2EthRpc, cfg.L2Rpc) require.Equal(t, l2EthRpc, cfg.L2Rpc)
...@@ -750,31 +711,30 @@ func TestCannonRequiredArgs(t *testing.T) { ...@@ -750,31 +711,30 @@ func TestCannonRequiredArgs(t *testing.T) {
t.Run(fmt.Sprintf("TestRequireEitherCannonNetworkOrRollupAndGenesis-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestRequireEitherCannonNetworkOrRollupAndGenesis-%v", traceType), func(t *testing.T) {
verifyArgsInvalid( verifyArgsInvalid(
t, t,
"flag cannon-network, network or cannon-rollup-config and cannon-l2-genesis is required", "flag network or rollup-config/cannon-rollup-config and l2-genesis/cannon-l2-genesis is required",
addRequiredArgsExcept(traceType, "--cannon-network")) addRequiredArgsExcept(traceType, "--network"))
verifyArgsInvalid( verifyArgsInvalid(
t, t,
"flag cannon-network, network or cannon-rollup-config and cannon-l2-genesis is required", "flag network or rollup-config/cannon-rollup-config and l2-genesis/cannon-l2-genesis is required",
addRequiredArgsExcept(traceType, "--cannon-network", "--cannon-rollup-config=rollup.json")) addRequiredArgsExcept(traceType, "--network", "--cannon-rollup-config=rollup.json"))
verifyArgsInvalid( verifyArgsInvalid(
t, t,
"flag cannon-network, network or cannon-rollup-config and cannon-l2-genesis is required", "flag network or rollup-config/cannon-rollup-config and l2-genesis/cannon-l2-genesis is required",
addRequiredArgsExcept(traceType, "--cannon-network", "--cannon-l2-genesis=gensis.json")) addRequiredArgsExcept(traceType, "--network", "--cannon-l2-genesis=gensis.json"))
}) })
t.Run(fmt.Sprintf("TestMustNotSpecifyCannonNetworkAndRollup-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) {
verifyArgsInvalid( verifyArgsInvalid(
t, t,
"flag cannon-network can not be used with cannon-rollup-config, cannon-l2-genesis or cannon-l2-custom", "flag network can not be used with cannon-rollup-config, l2-genesis or cannon-l2-custom",
addRequiredArgsExcept(traceType, "--cannon-network", addRequiredArgs(traceType, "--cannon-rollup-config=rollup.json"))
"--cannon-network", cannonNetwork, "--cannon-rollup-config=rollup.json"))
}) })
t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) {
args := requiredArgs(traceType) args := requiredArgs(traceType)
delete(args, "--cannon-network") delete(args, "--network")
delete(args, "--game-factory-address") delete(args, "--game-factory-address")
args["--network"] = cannonNetwork args["--network"] = network
args["--cannon-rollup-config"] = "rollup.json" args["--cannon-rollup-config"] = "rollup.json"
args["--cannon-l2-genesis"] = "gensis.json" args["--cannon-l2-genesis"] = "gensis.json"
args["--cannon-l2-custom"] = "true" args["--cannon-l2-custom"] = "true"
...@@ -784,38 +744,20 @@ func TestCannonRequiredArgs(t *testing.T) { ...@@ -784,38 +744,20 @@ func TestCannonRequiredArgs(t *testing.T) {
toArgList(args)) toArgList(args))
}) })
t.Run(fmt.Sprintf("TestCannonNetwork-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestNetwork-%v", traceType), func(t *testing.T) {
t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
configForArgs(t, addRequiredArgsExcept(types.TraceTypeAlphabet, "--cannon-network"))
})
t.Run("NotRequiredWhenRollupAndGenesIsSpecified", func(t *testing.T) { t.Run("NotRequiredWhenRollupAndGenesIsSpecified", func(t *testing.T) {
configForArgs(t, addRequiredArgsExcept(traceType, "--cannon-network", configForArgs(t, addRequiredArgsExcept(traceType, "--network",
"--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json")) "--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json"))
}) })
t.Run("NotRequiredWhenNetworkSpecified", func(t *testing.T) {
args := requiredArgs(traceType)
delete(args, "--cannon-network")
delete(args, "--game-factory-address")
args["--network"] = "op-sepolia"
cfg := configForArgs(t, toArgList(args))
require.Equal(t, "op-sepolia", cfg.Cannon.Network)
})
t.Run("MustNotSpecifyNetworkAndCannonNetwork", func(t *testing.T) {
verifyArgsInvalid(t, "flag cannon-network can not be used with network",
addRequiredArgsExcept(traceType, "--game-factory-address", "--network", "op-sepolia"))
})
t.Run("Valid", func(t *testing.T) { t.Run("Valid", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--cannon-network", "--cannon-network", testNetwork)) cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--network", testNetwork))
require.Equal(t, testNetwork, cfg.Cannon.Network) require.Equal(t, testNetwork, cfg.Cannon.Network)
}) })
}) })
t.Run(fmt.Sprintf("TestSetCannonL2ChainId-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestSetCannonL2ChainId-%v", traceType), func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--cannon-network", cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network",
"--cannon-rollup-config=rollup.json", "--cannon-rollup-config=rollup.json",
"--cannon-l2-genesis=genesis.json", "--cannon-l2-genesis=genesis.json",
"--cannon-l2-custom")) "--cannon-l2-custom"))
...@@ -828,7 +770,7 @@ func TestCannonRequiredArgs(t *testing.T) { ...@@ -828,7 +770,7 @@ func TestCannonRequiredArgs(t *testing.T) {
}) })
t.Run("Valid", func(t *testing.T) { t.Run("Valid", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--cannon-network", "--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json")) cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json"))
require.Equal(t, "rollup.json", cfg.Cannon.RollupConfigPath) require.Equal(t, "rollup.json", cfg.Cannon.RollupConfigPath)
}) })
}) })
...@@ -839,7 +781,7 @@ func TestCannonRequiredArgs(t *testing.T) { ...@@ -839,7 +781,7 @@ func TestCannonRequiredArgs(t *testing.T) {
}) })
t.Run("Valid", func(t *testing.T) { t.Run("Valid", func(t *testing.T) {
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--cannon-network", "--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json")) cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json"))
require.Equal(t, "genesis.json", cfg.Cannon.L2GenesisPath) require.Equal(t, "genesis.json", cfg.Cannon.L2GenesisPath)
}) })
}) })
...@@ -1050,21 +992,21 @@ func requiredArgs(traceType types.TraceType) map[string]string { ...@@ -1050,21 +992,21 @@ func requiredArgs(traceType types.TraceType) map[string]string {
} }
func addRequiredCannonArgs(args map[string]string) { func addRequiredCannonArgs(args map[string]string) {
args["--cannon-network"] = cannonNetwork args["--network"] = network
args["--cannon-bin"] = cannonBin args["--cannon-bin"] = cannonBin
args["--cannon-server"] = cannonServer args["--cannon-server"] = cannonServer
args["--cannon-prestate"] = cannonPreState args["--cannon-prestate"] = cannonPreState
} }
func addRequiredAsteriscArgs(args map[string]string) { func addRequiredAsteriscArgs(args map[string]string) {
args["--asterisc-network"] = asteriscNetwork args["--network"] = network
args["--asterisc-bin"] = asteriscBin args["--asterisc-bin"] = asteriscBin
args["--asterisc-server"] = asteriscServer args["--asterisc-server"] = asteriscServer
args["--asterisc-prestate"] = asteriscPreState args["--asterisc-prestate"] = asteriscPreState
} }
func addRequiredAsteriscKonaArgs(args map[string]string) { func addRequiredAsteriscKonaArgs(args map[string]string) {
args["--asterisc-network"] = asteriscNetwork args["--network"] = network
args["--asterisc-bin"] = asteriscBin args["--asterisc-bin"] = asteriscBin
args["--asterisc-kona-server"] = asteriscServer args["--asterisc-kona-server"] = asteriscServer
args["--asterisc-kona-prestate"] = asteriscPreState args["--asterisc-kona-prestate"] = asteriscPreState
......
op-challenger/config/config.go
View file @ 6f0d98c5
...@@ -4,15 +4,12 @@ import ( ...@@ -4,15 +4,12 @@ import (
"errors" "errors"
"fmt" "fmt"
"net/url" "net/url"
"os"
"runtime" "runtime"
"slices" "slices"
"strconv"
"time" "time"
"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/vm" "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/game/fault/types"
"github.com/ethereum-optimism/optimism/op-node/chaincfg"
opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics" opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
"github.com/ethereum-optimism/optimism/op-service/oppprof" "github.com/ethereum-optimism/optimism/op-service/oppprof"
"github.com/ethereum-optimism/optimism/op-service/txmgr" "github.com/ethereum-optimism/optimism/op-service/txmgr"
...@@ -24,42 +21,22 @@ var ( ...@@ -24,42 +21,22 @@ var (
ErrMissingDatadir = errors.New("missing datadir") ErrMissingDatadir = errors.New("missing datadir")
ErrMaxConcurrencyZero = errors.New("max concurrency must not be 0") ErrMaxConcurrencyZero = errors.New("max concurrency must not be 0")
ErrMissingL2Rpc = errors.New("missing L2 rpc url") ErrMissingL2Rpc = errors.New("missing L2 rpc url")
ErrMissingCannonBin = errors.New("missing cannon bin")
ErrMissingCannonServer = errors.New("missing cannon server")
ErrMissingCannonAbsolutePreState = errors.New("missing cannon absolute pre-state") ErrMissingCannonAbsolutePreState = errors.New("missing cannon absolute pre-state")
ErrMissingL1EthRPC = errors.New("missing l1 eth rpc url") ErrMissingL1EthRPC = errors.New("missing l1 eth rpc url")
ErrMissingL1Beacon = errors.New("missing l1 beacon url") ErrMissingL1Beacon = errors.New("missing l1 beacon url")
ErrMissingGameFactoryAddress = errors.New("missing game factory address") ErrMissingGameFactoryAddress = errors.New("missing game factory address")
ErrMissingCannonSnapshotFreq = errors.New("missing cannon snapshot freq") ErrMissingCannonSnapshotFreq = errors.New("missing cannon snapshot freq")
ErrMissingCannonInfoFreq = errors.New("missing cannon info freq") ErrMissingCannonInfoFreq = errors.New("missing cannon info freq")
ErrMissingCannonRollupConfig = errors.New("missing cannon network or rollup config path")
ErrMissingCannonL2Genesis = errors.New("missing cannon network or l2 genesis path")
ErrCannonNetworkAndRollupConfig = errors.New("only specify one of network or rollup config path")
ErrCannonNetworkAndL2Genesis = errors.New("only specify one of network or l2 genesis path")
ErrCannonNetworkUnknown = errors.New("unknown cannon network")
ErrMissingRollupRpc = errors.New("missing rollup rpc url") ErrMissingRollupRpc = errors.New("missing rollup rpc url")
ErrMissingAsteriscBin = errors.New("missing asterisc bin")
ErrMissingAsteriscServer = errors.New("missing asterisc server")
ErrMissingAsteriscAbsolutePreState = errors.New("missing asterisc absolute pre-state") ErrMissingAsteriscAbsolutePreState = errors.New("missing asterisc absolute pre-state")
ErrMissingAsteriscSnapshotFreq = errors.New("missing asterisc snapshot freq") ErrMissingAsteriscSnapshotFreq = errors.New("missing asterisc snapshot freq")
ErrMissingAsteriscInfoFreq = errors.New("missing asterisc info freq") ErrMissingAsteriscInfoFreq = errors.New("missing asterisc info freq")
ErrMissingAsteriscRollupConfig = errors.New("missing asterisc network or rollup config path")
ErrMissingAsteriscL2Genesis = errors.New("missing asterisc network or l2 genesis path")
ErrAsteriscNetworkAndRollupConfig = errors.New("only specify one of network or rollup config path")
ErrAsteriscNetworkAndL2Genesis = errors.New("only specify one of network or l2 genesis path")
ErrAsteriscNetworkUnknown = errors.New("unknown asterisc network")
ErrMissingAsteriscKonaBin = errors.New("missing asterisc kona bin")
ErrMissingAsteriscKonaServer = errors.New("missing asterisc kona server")
ErrMissingAsteriscKonaAbsolutePreState = errors.New("missing asterisc kona absolute pre-state") ErrMissingAsteriscKonaAbsolutePreState = errors.New("missing asterisc kona absolute pre-state")
ErrMissingAsteriscKonaSnapshotFreq = errors.New("missing asterisc kona snapshot freq") ErrMissingAsteriscKonaSnapshotFreq = errors.New("missing asterisc kona snapshot freq")
ErrMissingAsteriscKonaInfoFreq = errors.New("missing asterisc kona info freq") ErrMissingAsteriscKonaInfoFreq = errors.New("missing asterisc kona info freq")
ErrMissingAsteriscKonaRollupConfig = errors.New("missing asterisc kona network or rollup config path")
ErrMissingAsteriscKonaL2Genesis = errors.New("missing asterisc kona network or l2 genesis path")
ErrAsteriscKonaNetworkAndRollupConfig = errors.New("only specify one of network or rollup config path")
ErrAsteriscKonaNetworkAndL2Genesis = errors.New("only specify one of network or l2 genesis path")
ErrAsteriscKonaNetworkUnknown = errors.New("unknown asterisc kona network")
) )
const ( const (
...@@ -73,7 +50,7 @@ const ( ...@@ -73,7 +50,7 @@ const (
// The default value is 28 days. The worst case duration for a game is 16 days // The default value is 28 days. The worst case duration for a game is 16 days
// (due to clock extension), plus 7 days WETH withdrawal delay leaving a 5 day // (due to clock extension), plus 7 days WETH withdrawal delay leaving a 5 day
// buffer to monitor games to ensure bonds are claimed. // buffer to monitor games to ensure bonds are claimed.
DefaultGameWindow = time.Duration(28 * 24 * time.Hour) DefaultGameWindow = 28 * 24 * time.Hour
DefaultMaxPendingTx = 10 DefaultMaxPendingTx = 10
) )
...@@ -211,40 +188,8 @@ func (c Config) Check() error { ...@@ -211,40 +188,8 @@ func (c Config) Check() error {
return ErrMaxConcurrencyZero return ErrMaxConcurrencyZero
} }
if c.TraceTypeEnabled(types.TraceTypeCannon) || c.TraceTypeEnabled(types.TraceTypePermissioned) { if c.TraceTypeEnabled(types.TraceTypeCannon) || c.TraceTypeEnabled(types.TraceTypePermissioned) {
if c.Cannon.VmBin == "" { if err := c.Cannon.Check(); err != nil {
return ErrMissingCannonBin return fmt.Errorf("cannon: %w", err)
}
if c.Cannon.Server == "" {
return ErrMissingCannonServer
}
if _, err := os.Stat(c.Cannon.VmBin); err != nil {
return fmt.Errorf("%w: %w", ErrMissingCannonBin, err)
}
if _, err := os.Stat(c.Cannon.Server); err != nil {
return fmt.Errorf("%w: %w", ErrMissingCannonServer, err)
}
if c.Cannon.Network == "" {
if c.Cannon.RollupConfigPath == "" {
return ErrMissingCannonRollupConfig
}
if c.Cannon.L2GenesisPath == "" {
return ErrMissingCannonL2Genesis
}
} else {
if c.Cannon.RollupConfigPath != "" {
return ErrCannonNetworkAndRollupConfig
}
if c.Cannon.L2GenesisPath != "" {
return ErrCannonNetworkAndL2Genesis
}
if ch := chaincfg.ChainByName(c.Cannon.Network); ch == nil {
// Check if this looks like a chain ID that could be a custom chain configuration.
if _, err := strconv.ParseUint(c.Cannon.Network, 10, 32); err != nil {
return fmt.Errorf("%w: %v", ErrCannonNetworkUnknown, c.Cannon.Network)
}
}
} }
if c.CannonAbsolutePreState == "" && c.CannonAbsolutePreStateBaseURL == nil { if c.CannonAbsolutePreState == "" && c.CannonAbsolutePreStateBaseURL == nil {
return ErrMissingCannonAbsolutePreState return ErrMissingCannonAbsolutePreState
...@@ -257,37 +202,8 @@ func (c Config) Check() error { ...@@ -257,37 +202,8 @@ func (c Config) Check() error {
} }
} }
if c.TraceTypeEnabled(types.TraceTypeAsterisc) { if c.TraceTypeEnabled(types.TraceTypeAsterisc) {
if c.Asterisc.VmBin == "" { if err := c.Asterisc.Check(); err != nil {
return ErrMissingAsteriscBin return fmt.Errorf("asterisc: %w", err)
}
if c.Asterisc.Server == "" {
return ErrMissingAsteriscServer
}
if _, err := os.Stat(c.Asterisc.VmBin); err != nil {
return fmt.Errorf("%w: %w", ErrMissingAsteriscBin, err)
}
if _, err := os.Stat(c.Asterisc.Server); err != nil {
return fmt.Errorf("%w: %w", ErrMissingAsteriscServer, err)
}
if c.Asterisc.Network == "" {
if c.Asterisc.RollupConfigPath == "" {
return ErrMissingAsteriscRollupConfig
}
if c.Asterisc.L2GenesisPath == "" {
return ErrMissingAsteriscL2Genesis
}
} else {
if c.Asterisc.RollupConfigPath != "" {
return ErrAsteriscNetworkAndRollupConfig
}
if c.Asterisc.L2GenesisPath != "" {
return ErrAsteriscNetworkAndL2Genesis
}
if ch := chaincfg.ChainByName(c.Asterisc.Network); ch == nil {
return fmt.Errorf("%w: %v", ErrAsteriscNetworkUnknown, c.Asterisc.Network)
}
} }
if c.AsteriscAbsolutePreState == "" && c.AsteriscAbsolutePreStateBaseURL == nil { if c.AsteriscAbsolutePreState == "" && c.AsteriscAbsolutePreStateBaseURL == nil {
return ErrMissingAsteriscAbsolutePreState return ErrMissingAsteriscAbsolutePreState
...@@ -300,37 +216,8 @@ func (c Config) Check() error { ...@@ -300,37 +216,8 @@ func (c Config) Check() error {
} }
} }
if c.TraceTypeEnabled(types.TraceTypeAsteriscKona) { if c.TraceTypeEnabled(types.TraceTypeAsteriscKona) {
if c.AsteriscKona.VmBin == "" { if err := c.AsteriscKona.Check(); err != nil {
return ErrMissingAsteriscKonaBin return fmt.Errorf("asterisc kona: %w", err)
}
if c.AsteriscKona.Server == "" {
return ErrMissingAsteriscKonaServer
}
if _, err := os.Stat(c.AsteriscKona.VmBin); err != nil {
return fmt.Errorf("%w: %w", ErrMissingAsteriscKonaBin, err)
}
if _, err := os.Stat(c.AsteriscKona.Server); err != nil {
return fmt.Errorf("%w: %w", ErrMissingAsteriscKonaServer, err)
}
if c.AsteriscKona.Network == "" {
if c.AsteriscKona.RollupConfigPath == "" {
return ErrMissingAsteriscKonaRollupConfig
}
if c.AsteriscKona.L2GenesisPath == "" {
return ErrMissingAsteriscKonaL2Genesis
}
} else {
if c.AsteriscKona.RollupConfigPath != "" {
return ErrAsteriscKonaNetworkAndRollupConfig
}
if c.AsteriscKona.L2GenesisPath != "" {
return ErrAsteriscKonaNetworkAndL2Genesis
}
if ch := chaincfg.ChainByName(c.AsteriscKona.Network); ch == nil {
return fmt.Errorf("%w: %v", ErrAsteriscKonaNetworkUnknown, c.AsteriscKona.Network)
}
} }
if c.AsteriscKonaAbsolutePreState == "" && c.AsteriscKonaAbsolutePreStateBaseURL == nil { if c.AsteriscKonaAbsolutePreState == "" && c.AsteriscKonaAbsolutePreStateBaseURL == nil {
return ErrMissingAsteriscKonaAbsolutePreState return ErrMissingAsteriscKonaAbsolutePreState
......
op-challenger/config/config_test.go
View file @ 6f0d98c5
...@@ -8,6 +8,7 @@ import ( ...@@ -8,6 +8,7 @@ import (
"runtime" "runtime"
"testing" "testing"
"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/vm"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
...@@ -175,13 +176,13 @@ func TestCannonRequiredArgs(t *testing.T) { ...@@ -175,13 +176,13 @@ func TestCannonRequiredArgs(t *testing.T) {
t.Run(fmt.Sprintf("TestCannonBinRequired-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestCannonBinRequired-%v", traceType), func(t *testing.T) {
config := validConfig(t, traceType) config := validConfig(t, traceType)
config.Cannon.VmBin = "" config.Cannon.VmBin = ""
require.ErrorIs(t, config.Check(), ErrMissingCannonBin) require.ErrorIs(t, config.Check(), vm.ErrMissingBin)
}) })
t.Run(fmt.Sprintf("TestCannonServerRequired-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestCannonServerRequired-%v", traceType), func(t *testing.T) {
config := validConfig(t, traceType) config := validConfig(t, traceType)
config.Cannon.Server = "" config.Cannon.Server = ""
require.ErrorIs(t, config.Check(), ErrMissingCannonServer) require.ErrorIs(t, config.Check(), vm.ErrMissingServer)
}) })
t.Run(fmt.Sprintf("TestCannonAbsolutePreStateOrBaseURLRequired-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestCannonAbsolutePreStateOrBaseURLRequired-%v", traceType), func(t *testing.T) {
...@@ -240,7 +241,7 @@ func TestCannonRequiredArgs(t *testing.T) { ...@@ -240,7 +241,7 @@ func TestCannonRequiredArgs(t *testing.T) {
cfg.Cannon.Network = "" cfg.Cannon.Network = ""
cfg.Cannon.RollupConfigPath = "" cfg.Cannon.RollupConfigPath = ""
cfg.Cannon.L2GenesisPath = "genesis.json" cfg.Cannon.L2GenesisPath = "genesis.json"
require.ErrorIs(t, cfg.Check(), ErrMissingCannonRollupConfig) require.ErrorIs(t, cfg.Check(), vm.ErrMissingRollupConfig)
}) })
t.Run(fmt.Sprintf("TestCannonNetworkOrL2GenesisRequired-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestCannonNetworkOrL2GenesisRequired-%v", traceType), func(t *testing.T) {
...@@ -248,7 +249,7 @@ func TestCannonRequiredArgs(t *testing.T) { ...@@ -248,7 +249,7 @@ func TestCannonRequiredArgs(t *testing.T) {
cfg.Cannon.Network = "" cfg.Cannon.Network = ""
cfg.Cannon.RollupConfigPath = "foo.json" cfg.Cannon.RollupConfigPath = "foo.json"
cfg.Cannon.L2GenesisPath = "" cfg.Cannon.L2GenesisPath = ""
require.ErrorIs(t, cfg.Check(), ErrMissingCannonL2Genesis) require.ErrorIs(t, cfg.Check(), vm.ErrMissingL2Genesis)
}) })
t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) {
...@@ -256,7 +257,7 @@ func TestCannonRequiredArgs(t *testing.T) { ...@@ -256,7 +257,7 @@ func TestCannonRequiredArgs(t *testing.T) {
cfg.Cannon.Network = validCannonNetwork cfg.Cannon.Network = validCannonNetwork
cfg.Cannon.RollupConfigPath = "foo.json" cfg.Cannon.RollupConfigPath = "foo.json"
cfg.Cannon.L2GenesisPath = "" cfg.Cannon.L2GenesisPath = ""
require.ErrorIs(t, cfg.Check(), ErrCannonNetworkAndRollupConfig) require.ErrorIs(t, cfg.Check(), vm.ErrNetworkAndRollupConfig)
}) })
t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndL2Genesis-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndL2Genesis-%v", traceType), func(t *testing.T) {
...@@ -264,13 +265,13 @@ func TestCannonRequiredArgs(t *testing.T) { ...@@ -264,13 +265,13 @@ func TestCannonRequiredArgs(t *testing.T) {
cfg.Cannon.Network = validCannonNetwork cfg.Cannon.Network = validCannonNetwork
cfg.Cannon.RollupConfigPath = "" cfg.Cannon.RollupConfigPath = ""
cfg.Cannon.L2GenesisPath = "foo.json" cfg.Cannon.L2GenesisPath = "foo.json"
require.ErrorIs(t, cfg.Check(), ErrCannonNetworkAndL2Genesis) require.ErrorIs(t, cfg.Check(), vm.ErrNetworkAndL2Genesis)
}) })
t.Run(fmt.Sprintf("TestNetworkMustBeValid-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestNetworkMustBeValid-%v", traceType), func(t *testing.T) {
cfg := validConfig(t, traceType) cfg := validConfig(t, traceType)
cfg.Cannon.Network = "unknown" cfg.Cannon.Network = "unknown"
require.ErrorIs(t, cfg.Check(), ErrCannonNetworkUnknown) require.ErrorIs(t, cfg.Check(), vm.ErrNetworkUnknown)
}) })
t.Run(fmt.Sprintf("TestNetworkMayBeAnyChainID-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestNetworkMayBeAnyChainID-%v", traceType), func(t *testing.T) {
...@@ -282,7 +283,7 @@ func TestCannonRequiredArgs(t *testing.T) { ...@@ -282,7 +283,7 @@ func TestCannonRequiredArgs(t *testing.T) {
t.Run(fmt.Sprintf("TestNetworkInvalidWhenNotEntirelyNumeric-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestNetworkInvalidWhenNotEntirelyNumeric-%v", traceType), func(t *testing.T) {
cfg := validConfig(t, traceType) cfg := validConfig(t, traceType)
cfg.Cannon.Network = "467294a" cfg.Cannon.Network = "467294a"
require.ErrorIs(t, cfg.Check(), ErrCannonNetworkUnknown) require.ErrorIs(t, cfg.Check(), vm.ErrNetworkUnknown)
}) })
t.Run(fmt.Sprintf("TestDebugInfoEnabled-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestDebugInfoEnabled-%v", traceType), func(t *testing.T) {
...@@ -293,13 +294,13 @@ func TestCannonRequiredArgs(t *testing.T) { ...@@ -293,13 +294,13 @@ func TestCannonRequiredArgs(t *testing.T) {
t.Run(fmt.Sprintf("TestVMBinExists-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestVMBinExists-%v", traceType), func(t *testing.T) {
cfg := validConfig(t, traceType) cfg := validConfig(t, traceType)
cfg.Cannon.VmBin = nonExistingFile cfg.Cannon.VmBin = nonExistingFile
require.ErrorIs(t, cfg.Check(), ErrMissingCannonBin) require.ErrorIs(t, cfg.Check(), vm.ErrMissingBin)
}) })
t.Run(fmt.Sprintf("TestServerExists-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestServerExists-%v", traceType), func(t *testing.T) {
cfg := validConfig(t, traceType) cfg := validConfig(t, traceType)
cfg.Cannon.Server = nonExistingFile cfg.Cannon.Server = nonExistingFile
require.ErrorIs(t, cfg.Check(), ErrMissingCannonServer) require.ErrorIs(t, cfg.Check(), vm.ErrMissingServer)
}) })
} }
} }
...@@ -311,13 +312,13 @@ func TestAsteriscRequiredArgs(t *testing.T) { ...@@ -311,13 +312,13 @@ func TestAsteriscRequiredArgs(t *testing.T) {
t.Run(fmt.Sprintf("TestAsteriscBinRequired-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestAsteriscBinRequired-%v", traceType), func(t *testing.T) {
config := validConfig(t, traceType) config := validConfig(t, traceType)
config.Asterisc.VmBin = "" config.Asterisc.VmBin = ""
require.ErrorIs(t, config.Check(), ErrMissingAsteriscBin) require.ErrorIs(t, config.Check(), vm.ErrMissingBin)
}) })
t.Run(fmt.Sprintf("TestAsteriscServerRequired-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestAsteriscServerRequired-%v", traceType), func(t *testing.T) {
config := validConfig(t, traceType) config := validConfig(t, traceType)
config.Asterisc.Server = "" config.Asterisc.Server = ""
require.ErrorIs(t, config.Check(), ErrMissingAsteriscServer) require.ErrorIs(t, config.Check(), vm.ErrMissingServer)
}) })
t.Run(fmt.Sprintf("TestAsteriscAbsolutePreStateOrBaseURLRequired-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestAsteriscAbsolutePreStateOrBaseURLRequired-%v", traceType), func(t *testing.T) {
...@@ -376,7 +377,7 @@ func TestAsteriscRequiredArgs(t *testing.T) { ...@@ -376,7 +377,7 @@ func TestAsteriscRequiredArgs(t *testing.T) {
cfg.Asterisc.Network = "" cfg.Asterisc.Network = ""
cfg.Asterisc.RollupConfigPath = "" cfg.Asterisc.RollupConfigPath = ""
cfg.Asterisc.L2GenesisPath = "genesis.json" cfg.Asterisc.L2GenesisPath = "genesis.json"
require.ErrorIs(t, cfg.Check(), ErrMissingAsteriscRollupConfig) require.ErrorIs(t, cfg.Check(), vm.ErrMissingRollupConfig)
}) })
t.Run(fmt.Sprintf("TestAsteriscNetworkOrL2GenesisRequired-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestAsteriscNetworkOrL2GenesisRequired-%v", traceType), func(t *testing.T) {
...@@ -384,7 +385,7 @@ func TestAsteriscRequiredArgs(t *testing.T) { ...@@ -384,7 +385,7 @@ func TestAsteriscRequiredArgs(t *testing.T) {
cfg.Asterisc.Network = "" cfg.Asterisc.Network = ""
cfg.Asterisc.RollupConfigPath = "foo.json" cfg.Asterisc.RollupConfigPath = "foo.json"
cfg.Asterisc.L2GenesisPath = "" cfg.Asterisc.L2GenesisPath = ""
require.ErrorIs(t, cfg.Check(), ErrMissingAsteriscL2Genesis) require.ErrorIs(t, cfg.Check(), vm.ErrMissingL2Genesis)
}) })
t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) {
...@@ -392,7 +393,7 @@ func TestAsteriscRequiredArgs(t *testing.T) { ...@@ -392,7 +393,7 @@ func TestAsteriscRequiredArgs(t *testing.T) {
cfg.Asterisc.Network = validAsteriscNetwork cfg.Asterisc.Network = validAsteriscNetwork
cfg.Asterisc.RollupConfigPath = "foo.json" cfg.Asterisc.RollupConfigPath = "foo.json"
cfg.Asterisc.L2GenesisPath = "" cfg.Asterisc.L2GenesisPath = ""
require.ErrorIs(t, cfg.Check(), ErrAsteriscNetworkAndRollupConfig) require.ErrorIs(t, cfg.Check(), vm.ErrNetworkAndRollupConfig)
}) })
t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndL2Genesis-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndL2Genesis-%v", traceType), func(t *testing.T) {
...@@ -400,13 +401,13 @@ func TestAsteriscRequiredArgs(t *testing.T) { ...@@ -400,13 +401,13 @@ func TestAsteriscRequiredArgs(t *testing.T) {
cfg.Asterisc.Network = validAsteriscNetwork cfg.Asterisc.Network = validAsteriscNetwork
cfg.Asterisc.RollupConfigPath = "" cfg.Asterisc.RollupConfigPath = ""
cfg.Asterisc.L2GenesisPath = "foo.json" cfg.Asterisc.L2GenesisPath = "foo.json"
require.ErrorIs(t, cfg.Check(), ErrAsteriscNetworkAndL2Genesis) require.ErrorIs(t, cfg.Check(), vm.ErrNetworkAndL2Genesis)
}) })
t.Run(fmt.Sprintf("TestNetworkMustBeValid-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestNetworkMustBeValid-%v", traceType), func(t *testing.T) {
cfg := validConfig(t, traceType) cfg := validConfig(t, traceType)
cfg.Asterisc.Network = "unknown" cfg.Asterisc.Network = "unknown"
require.ErrorIs(t, cfg.Check(), ErrAsteriscNetworkUnknown) require.ErrorIs(t, cfg.Check(), vm.ErrNetworkUnknown)
}) })
t.Run(fmt.Sprintf("TestDebugInfoDisabled-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestDebugInfoDisabled-%v", traceType), func(t *testing.T) {
...@@ -417,13 +418,13 @@ func TestAsteriscRequiredArgs(t *testing.T) { ...@@ -417,13 +418,13 @@ func TestAsteriscRequiredArgs(t *testing.T) {
t.Run(fmt.Sprintf("TestVMBinExists-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestVMBinExists-%v", traceType), func(t *testing.T) {
cfg := validConfig(t, traceType) cfg := validConfig(t, traceType)
cfg.Asterisc.VmBin = nonExistingFile cfg.Asterisc.VmBin = nonExistingFile
require.ErrorIs(t, cfg.Check(), ErrMissingAsteriscBin) require.ErrorIs(t, cfg.Check(), vm.ErrMissingBin)
}) })
t.Run(fmt.Sprintf("TestServerExists-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestServerExists-%v", traceType), func(t *testing.T) {
cfg := validConfig(t, traceType) cfg := validConfig(t, traceType)
cfg.Asterisc.Server = nonExistingFile cfg.Asterisc.Server = nonExistingFile
require.ErrorIs(t, cfg.Check(), ErrMissingAsteriscServer) require.ErrorIs(t, cfg.Check(), vm.ErrMissingServer)
}) })
} }
} }
...@@ -435,13 +436,13 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) { ...@@ -435,13 +436,13 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) {
t.Run(fmt.Sprintf("TestAsteriscKonaBinRequired-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestAsteriscKonaBinRequired-%v", traceType), func(t *testing.T) {
config := validConfig(t, traceType) config := validConfig(t, traceType)
config.AsteriscKona.VmBin = "" config.AsteriscKona.VmBin = ""
require.ErrorIs(t, config.Check(), ErrMissingAsteriscKonaBin) require.ErrorIs(t, config.Check(), vm.ErrMissingBin)
}) })
t.Run(fmt.Sprintf("TestAsteriscKonaServerRequired-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestAsteriscKonaServerRequired-%v", traceType), func(t *testing.T) {
config := validConfig(t, traceType) config := validConfig(t, traceType)
config.AsteriscKona.Server = "" config.AsteriscKona.Server = ""
require.ErrorIs(t, config.Check(), ErrMissingAsteriscKonaServer) require.ErrorIs(t, config.Check(), vm.ErrMissingServer)
}) })
t.Run(fmt.Sprintf("TestAsteriscKonaAbsolutePreStateOrBaseURLRequired-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestAsteriscKonaAbsolutePreStateOrBaseURLRequired-%v", traceType), func(t *testing.T) {
...@@ -500,7 +501,7 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) { ...@@ -500,7 +501,7 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) {
cfg.AsteriscKona.Network = "" cfg.AsteriscKona.Network = ""
cfg.AsteriscKona.RollupConfigPath = "" cfg.AsteriscKona.RollupConfigPath = ""
cfg.AsteriscKona.L2GenesisPath = "genesis.json" cfg.AsteriscKona.L2GenesisPath = "genesis.json"
require.ErrorIs(t, cfg.Check(), ErrMissingAsteriscKonaRollupConfig) require.ErrorIs(t, cfg.Check(), vm.ErrMissingRollupConfig)
}) })
t.Run(fmt.Sprintf("TestAsteriscKonaNetworkOrL2GenesisRequired-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestAsteriscKonaNetworkOrL2GenesisRequired-%v", traceType), func(t *testing.T) {
...@@ -508,7 +509,7 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) { ...@@ -508,7 +509,7 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) {
cfg.AsteriscKona.Network = "" cfg.AsteriscKona.Network = ""
cfg.AsteriscKona.RollupConfigPath = "foo.json" cfg.AsteriscKona.RollupConfigPath = "foo.json"
cfg.AsteriscKona.L2GenesisPath = "" cfg.AsteriscKona.L2GenesisPath = ""
require.ErrorIs(t, cfg.Check(), ErrMissingAsteriscKonaL2Genesis) require.ErrorIs(t, cfg.Check(), vm.ErrMissingL2Genesis)
}) })
t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) {
...@@ -516,7 +517,7 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) { ...@@ -516,7 +517,7 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) {
cfg.AsteriscKona.Network = validAsteriscKonaNetwork cfg.AsteriscKona.Network = validAsteriscKonaNetwork
cfg.AsteriscKona.RollupConfigPath = "foo.json" cfg.AsteriscKona.RollupConfigPath = "foo.json"
cfg.AsteriscKona.L2GenesisPath = "" cfg.AsteriscKona.L2GenesisPath = ""
require.ErrorIs(t, cfg.Check(), ErrAsteriscKonaNetworkAndRollupConfig) require.ErrorIs(t, cfg.Check(), vm.ErrNetworkAndRollupConfig)
}) })
t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndL2Genesis-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndL2Genesis-%v", traceType), func(t *testing.T) {
...@@ -524,13 +525,13 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) { ...@@ -524,13 +525,13 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) {
cfg.AsteriscKona.Network = validAsteriscKonaNetwork cfg.AsteriscKona.Network = validAsteriscKonaNetwork
cfg.AsteriscKona.RollupConfigPath = "" cfg.AsteriscKona.RollupConfigPath = ""
cfg.AsteriscKona.L2GenesisPath = "foo.json" cfg.AsteriscKona.L2GenesisPath = "foo.json"
require.ErrorIs(t, cfg.Check(), ErrAsteriscKonaNetworkAndL2Genesis) require.ErrorIs(t, cfg.Check(), vm.ErrNetworkAndL2Genesis)
}) })
t.Run(fmt.Sprintf("TestNetworkMustBeValid-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestNetworkMustBeValid-%v", traceType), func(t *testing.T) {
cfg := validConfig(t, traceType) cfg := validConfig(t, traceType)
cfg.AsteriscKona.Network = "unknown" cfg.AsteriscKona.Network = "unknown"
require.ErrorIs(t, cfg.Check(), ErrAsteriscKonaNetworkUnknown) require.ErrorIs(t, cfg.Check(), vm.ErrNetworkUnknown)
}) })
t.Run(fmt.Sprintf("TestDebugInfoDisabled-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestDebugInfoDisabled-%v", traceType), func(t *testing.T) {
...@@ -541,13 +542,13 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) { ...@@ -541,13 +542,13 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) {
t.Run(fmt.Sprintf("TestVMBinExists-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestVMBinExists-%v", traceType), func(t *testing.T) {
cfg := validConfig(t, traceType) cfg := validConfig(t, traceType)
cfg.AsteriscKona.VmBin = nonExistingFile cfg.AsteriscKona.VmBin = nonExistingFile
require.ErrorIs(t, cfg.Check(), ErrMissingAsteriscKonaBin) require.ErrorIs(t, cfg.Check(), vm.ErrMissingBin)
}) })
t.Run(fmt.Sprintf("TestServerExists-%v", traceType), func(t *testing.T) { t.Run(fmt.Sprintf("TestServerExists-%v", traceType), func(t *testing.T) {
cfg := validConfig(t, traceType) cfg := validConfig(t, traceType)
cfg.AsteriscKona.Server = nonExistingFile cfg.AsteriscKona.Server = nonExistingFile
require.ErrorIs(t, cfg.Check(), ErrMissingAsteriscKonaServer) require.ErrorIs(t, cfg.Check(), vm.ErrMissingServer)
}) })
} }
} }
...@@ -636,7 +637,7 @@ func TestRequireConfigForMultipleTraceTypesForCannonAndAsterisc(t *testing.T) { ...@@ -636,7 +637,7 @@ func TestRequireConfigForMultipleTraceTypesForCannonAndAsterisc(t *testing.T) {
// Require cannon specific args // Require cannon specific args
cfg.Cannon.VmBin = "" cfg.Cannon.VmBin = ""
require.ErrorIs(t, cfg.Check(), ErrMissingCannonBin) require.ErrorIs(t, cfg.Check(), vm.ErrMissingBin)
tmpDir := t.TempDir() tmpDir := t.TempDir()
vmBin := filepath.Join(tmpDir, validCannonBin) vmBin := filepath.Join(tmpDir, validCannonBin)
err := ensureExists(vmBin) err := ensureExists(vmBin)
...@@ -649,9 +650,8 @@ func TestRequireConfigForMultipleTraceTypesForCannonAndAsterisc(t *testing.T) { ...@@ -649,9 +650,8 @@ func TestRequireConfigForMultipleTraceTypesForCannonAndAsterisc(t *testing.T) {
require.ErrorIs(t, cfg.Check(), ErrMissingAsteriscAbsolutePreState) require.ErrorIs(t, cfg.Check(), ErrMissingAsteriscAbsolutePreState)
cfg.AsteriscAbsolutePreState = validAsteriscAbsolutePreState cfg.AsteriscAbsolutePreState = validAsteriscAbsolutePreState
// Require cannon specific args
cfg.Asterisc.Server = "" cfg.Asterisc.Server = ""
require.ErrorIs(t, cfg.Check(), ErrMissingAsteriscServer) require.ErrorIs(t, cfg.Check(), vm.ErrMissingServer)
server := filepath.Join(tmpDir, validAsteriscOpProgramBin) server := filepath.Join(tmpDir, validAsteriscOpProgramBin)
err = ensureExists(server) err = ensureExists(server)
require.NoError(t, err) require.NoError(t, err)
......
op-challenger/flags/flags.go
View file @ 6f0d98c5
...@@ -81,7 +81,7 @@ var ( ...@@ -81,7 +81,7 @@ var (
} }
L2EthRpcFlag = &cli.StringFlag{ L2EthRpcFlag = &cli.StringFlag{
Name: "l2-eth-rpc", Name: "l2-eth-rpc",
Usage: "L2 Address of L2 JSON-RPC endpoint to use (eth and debug namespace required) (cannon/asterisc trace type only)", Usage: "L2 Address of L2 JSON-RPC endpoint to use (eth and debug namespace required)",
EnvVars: prefixEnvVars("L2_ETH_RPC"), EnvVars: prefixEnvVars("L2_ETH_RPC"),
} }
MaxPendingTransactionsFlag = &cli.Uint64Flag{ MaxPendingTransactionsFlag = &cli.Uint64Flag{
...@@ -110,11 +110,20 @@ var ( ...@@ -110,11 +110,20 @@ var (
EnvVars: envVars, EnvVars: envVars,
} }
}) })
CannonNetworkFlag = &cli.StringFlag{ RollupConfigFlag = NewVMFlag("rollup-config", EnvVarPrefix, faultDisputeVMs, func(name string, envVars []string, traceTypeInfo string) cli.Flag {
Name: "cannon-network", return &cli.StringFlag{
Usage: fmt.Sprintf("Deprecated: Use %v instead", flags.NetworkFlagName), Name: name,
EnvVars: prefixEnvVars("CANNON_NETWORK"), Usage: "Rollup chain parameters " + traceTypeInfo,
EnvVars: envVars,
} }
})
L2GenesisFlag = NewVMFlag("l2-genesis", EnvVarPrefix, faultDisputeVMs, func(name string, envVars []string, traceTypeInfo string) cli.Flag {
return &cli.StringFlag{
Name: name,
Usage: "Path to the op-geth genesis file " + traceTypeInfo,
EnvVars: envVars,
}
})
CannonL2CustomFlag = &cli.BoolFlag{ CannonL2CustomFlag = &cli.BoolFlag{
Name: "cannon-l2-custom", Name: "cannon-l2-custom",
Usage: "Notify the op-program host that the L2 chain uses custom config to be loaded via the preimage oracle. " + Usage: "Notify the op-program host that the L2 chain uses custom config to be loaded via the preimage oracle. " +
...@@ -123,16 +132,6 @@ var ( ...@@ -123,16 +132,6 @@ var (
Value: false, Value: false,
Hidden: true, Hidden: true,
} }
CannonRollupConfigFlag = &cli.StringFlag{
Name: "cannon-rollup-config",
Usage: "Rollup chain parameters (cannon trace type only)",
EnvVars: prefixEnvVars("CANNON_ROLLUP_CONFIG"),
}
CannonL2GenesisFlag = &cli.StringFlag{
Name: "cannon-l2-genesis",
Usage: "Path to the op-geth genesis file (cannon trace type only)",
EnvVars: prefixEnvVars("CANNON_L2_GENESIS"),
}
CannonBinFlag = &cli.StringFlag{ CannonBinFlag = &cli.StringFlag{
Name: "cannon-bin", Name: "cannon-bin",
Usage: "Path to cannon executable to use when generating trace data (cannon trace type only)", Usage: "Path to cannon executable to use when generating trace data (cannon trace type only)",
...@@ -148,11 +147,6 @@ var ( ...@@ -148,11 +147,6 @@ var (
Usage: "Path to absolute prestate to use when generating trace data (cannon trace type only)", Usage: "Path to absolute prestate to use when generating trace data (cannon trace type only)",
EnvVars: prefixEnvVars("CANNON_PRESTATE"), EnvVars: prefixEnvVars("CANNON_PRESTATE"),
} }
CannonL2Flag = &cli.StringFlag{
Name: "cannon-l2",
Usage: fmt.Sprintf("Deprecated: Use %v instead", L2EthRpcFlag.Name),
EnvVars: prefixEnvVars("CANNON_L2"),
}
CannonSnapshotFreqFlag = &cli.UintFlag{ CannonSnapshotFreqFlag = &cli.UintFlag{
Name: "cannon-snapshot-freq", Name: "cannon-snapshot-freq",
Usage: "Frequency of cannon snapshots to generate in VM steps (cannon trace type only)", Usage: "Frequency of cannon snapshots to generate in VM steps (cannon trace type only)",
...@@ -165,21 +159,6 @@ var ( ...@@ -165,21 +159,6 @@ var (
EnvVars: prefixEnvVars("CANNON_INFO_FREQ"), EnvVars: prefixEnvVars("CANNON_INFO_FREQ"),
Value: config.DefaultCannonInfoFreq, Value: config.DefaultCannonInfoFreq,
} }
AsteriscNetworkFlag = &cli.StringFlag{
Name: "asterisc-network",
Usage: fmt.Sprintf("Deprecated: Use %v instead", flags.NetworkFlagName),
EnvVars: prefixEnvVars("ASTERISC_NETWORK"),
}
AsteriscRollupConfigFlag = &cli.StringFlag{
Name: "asterisc-rollup-config",
Usage: "Rollup chain parameters (asterisc trace type only)",
EnvVars: prefixEnvVars("ASTERISC_ROLLUP_CONFIG"),
}
AsteriscL2GenesisFlag = &cli.StringFlag{
Name: "asterisc-l2-genesis",
Usage: "Path to the op-geth genesis file (asterisc trace type only)",
EnvVars: prefixEnvVars("ASTERISC_L2_GENESIS"),
}
AsteriscBinFlag = &cli.StringFlag{ AsteriscBinFlag = &cli.StringFlag{
Name: "asterisc-bin", Name: "asterisc-bin",
Usage: "Path to asterisc executable to use when generating trace data (asterisc trace type only)", Usage: "Path to asterisc executable to use when generating trace data (asterisc trace type only)",
...@@ -256,19 +235,12 @@ var optionalFlags = []cli.Flag{ ...@@ -256,19 +235,12 @@ var optionalFlags = []cli.Flag{
HTTPPollInterval, HTTPPollInterval,
AdditionalBondClaimants, AdditionalBondClaimants,
GameAllowlistFlag, GameAllowlistFlag,
CannonNetworkFlag,
CannonL2CustomFlag, CannonL2CustomFlag,
CannonRollupConfigFlag,
CannonL2GenesisFlag,
CannonBinFlag, CannonBinFlag,
CannonServerFlag, CannonServerFlag,
CannonPreStateFlag, CannonPreStateFlag,
CannonL2Flag,
CannonSnapshotFreqFlag, CannonSnapshotFreqFlag,
CannonInfoFreqFlag, CannonInfoFreqFlag,
AsteriscNetworkFlag,
AsteriscRollupConfigFlag,
AsteriscL2GenesisFlag,
AsteriscBinFlag, AsteriscBinFlag,
AsteriscServerFlag, AsteriscServerFlag,
AsteriscKonaServerFlag, AsteriscKonaServerFlag,
...@@ -284,6 +256,8 @@ var optionalFlags = []cli.Flag{ ...@@ -284,6 +256,8 @@ var optionalFlags = []cli.Flag{
func init() { func init() {
optionalFlags = append(optionalFlags, oplog.CLIFlags(EnvVarPrefix)...) optionalFlags = append(optionalFlags, oplog.CLIFlags(EnvVarPrefix)...)
optionalFlags = append(optionalFlags, PreStatesURLFlag.Flags()...) optionalFlags = append(optionalFlags, PreStatesURLFlag.Flags()...)
optionalFlags = append(optionalFlags, RollupConfigFlag.Flags()...)
optionalFlags = append(optionalFlags, L2GenesisFlag.Flags()...)
optionalFlags = append(optionalFlags, txmgr.CLIFlagsWithDefaults(EnvVarPrefix, txmgr.DefaultChallengerFlagValues)...) optionalFlags = append(optionalFlags, txmgr.CLIFlagsWithDefaults(EnvVarPrefix, txmgr.DefaultChallengerFlagValues)...)
optionalFlags = append(optionalFlags, opmetrics.CLIFlags(EnvVarPrefix)...) optionalFlags = append(optionalFlags, opmetrics.CLIFlags(EnvVarPrefix)...)
optionalFlags = append(optionalFlags, oppprof.CLIFlags(EnvVarPrefix)...) optionalFlags = append(optionalFlags, oppprof.CLIFlags(EnvVarPrefix)...)
...@@ -295,27 +269,19 @@ func init() { ...@@ -295,27 +269,19 @@ func init() {
var Flags []cli.Flag var Flags []cli.Flag
func CheckCannonFlags(ctx *cli.Context) error { func CheckCannonFlags(ctx *cli.Context) error {
if ctx.IsSet(CannonNetworkFlag.Name) && ctx.IsSet(flags.NetworkFlagName) { if !ctx.IsSet(flags.NetworkFlagName) &&
return fmt.Errorf("flag %v can not be used with %v", CannonNetworkFlag.Name, flags.NetworkFlagName) !(RollupConfigFlag.IsSet(ctx, types.TraceTypeCannon) && L2GenesisFlag.IsSet(ctx, types.TraceTypeCannon)) {
} return fmt.Errorf("flag %v or %v and %v is required",
if !ctx.IsSet(CannonNetworkFlag.Name) && flags.NetworkFlagName, RollupConfigFlag.EitherFlagName(types.TraceTypeCannon), L2GenesisFlag.EitherFlagName(types.TraceTypeCannon))
!ctx.IsSet(flags.NetworkFlagName) &&
!(ctx.IsSet(CannonRollupConfigFlag.Name) && ctx.IsSet(CannonL2GenesisFlag.Name)) {
return fmt.Errorf("flag %v, %v or %v and %v is required",
CannonNetworkFlag.Name, flags.NetworkFlagName, CannonRollupConfigFlag.Name, CannonL2GenesisFlag.Name)
} }
if ctx.IsSet(flags.NetworkFlagName) && if ctx.IsSet(flags.NetworkFlagName) &&
(ctx.IsSet(CannonRollupConfigFlag.Name) || ctx.IsSet(CannonL2GenesisFlag.Name) || ctx.Bool(CannonL2CustomFlag.Name)) { (RollupConfigFlag.IsSet(ctx, types.TraceTypeCannon) || L2GenesisFlag.IsSet(ctx, types.TraceTypeCannon) || ctx.Bool(CannonL2CustomFlag.Name)) {
return fmt.Errorf("flag %v can not be used with %v, %v or %v",
flags.NetworkFlagName, CannonRollupConfigFlag.Name, CannonL2GenesisFlag.Name, CannonL2CustomFlag.Name)
}
if ctx.IsSet(CannonNetworkFlag.Name) &&
(ctx.IsSet(CannonRollupConfigFlag.Name) || ctx.IsSet(CannonL2GenesisFlag.Name) || ctx.Bool(CannonL2CustomFlag.Name)) {
return fmt.Errorf("flag %v can not be used with %v, %v or %v", return fmt.Errorf("flag %v can not be used with %v, %v or %v",
CannonNetworkFlag.Name, CannonRollupConfigFlag.Name, CannonL2GenesisFlag.Name, CannonL2CustomFlag.Name) flags.NetworkFlagName, RollupConfigFlag.SourceFlagName(ctx, types.TraceTypeCannon), L2GenesisFlag.SourceFlagName(ctx, types.TraceTypeCannon), CannonL2CustomFlag.Name)
} }
if ctx.Bool(CannonL2CustomFlag.Name) && !(ctx.IsSet(CannonRollupConfigFlag.Name) && ctx.IsSet(CannonL2GenesisFlag.Name)) { if ctx.Bool(CannonL2CustomFlag.Name) && !(RollupConfigFlag.IsSet(ctx, types.TraceTypeCannon) && L2GenesisFlag.IsSet(ctx, types.TraceTypeCannon)) {
return fmt.Errorf("flag %v and %v must be set when %v is true", CannonRollupConfigFlag.Name, CannonL2GenesisFlag.Name, CannonL2CustomFlag.Name) return fmt.Errorf("flag %v and %v must be set when %v is true",
RollupConfigFlag.EitherFlagName(types.TraceTypeCannon), L2GenesisFlag.EitherFlagName(types.TraceTypeCannon), CannonL2CustomFlag.Name)
} }
if !ctx.IsSet(CannonBinFlag.Name) { if !ctx.IsSet(CannonBinFlag.Name) {
return fmt.Errorf("flag %s is required", CannonBinFlag.Name) return fmt.Errorf("flag %s is required", CannonBinFlag.Name)
...@@ -324,30 +290,21 @@ func CheckCannonFlags(ctx *cli.Context) error { ...@@ -324,30 +290,21 @@ func CheckCannonFlags(ctx *cli.Context) error {
return fmt.Errorf("flag %s is required", CannonServerFlag.Name) return fmt.Errorf("flag %s is required", CannonServerFlag.Name)
} }
if !PreStatesURLFlag.IsSet(ctx, types.TraceTypeCannon) && !ctx.IsSet(CannonPreStateFlag.Name) { if !PreStatesURLFlag.IsSet(ctx, types.TraceTypeCannon) && !ctx.IsSet(CannonPreStateFlag.Name) {
return fmt.Errorf("flag %s or %s is required", PreStatesURLFlag.DefaultName(), CannonPreStateFlag.Name) return fmt.Errorf("flag %s or %s is required", PreStatesURLFlag.EitherFlagName(types.TraceTypeCannon), CannonPreStateFlag.Name)
} }
return nil return nil
} }
func CheckAsteriscBaseFlags(ctx *cli.Context) error { func CheckAsteriscBaseFlags(ctx *cli.Context, traceType types.TraceType) error {
if ctx.IsSet(AsteriscNetworkFlag.Name) && ctx.IsSet(flags.NetworkFlagName) { if !ctx.IsSet(flags.NetworkFlagName) &&
return fmt.Errorf("flag %v can not be used with %v", AsteriscNetworkFlag.Name, flags.NetworkFlagName) !(RollupConfigFlag.IsSet(ctx, traceType) && L2GenesisFlag.IsSet(ctx, traceType)) {
} return fmt.Errorf("flag %v or %v and %v is required",
if !ctx.IsSet(AsteriscNetworkFlag.Name) && flags.NetworkFlagName, RollupConfigFlag.EitherFlagName(traceType), L2GenesisFlag.EitherFlagName(traceType))
!ctx.IsSet(flags.NetworkFlagName) &&
!(ctx.IsSet(AsteriscRollupConfigFlag.Name) && ctx.IsSet(AsteriscL2GenesisFlag.Name)) {
return fmt.Errorf("flag %v, %v or %v and %v is required",
AsteriscNetworkFlag.Name, flags.NetworkFlagName, AsteriscRollupConfigFlag.Name, AsteriscL2GenesisFlag.Name)
} }
if ctx.IsSet(flags.NetworkFlagName) && if ctx.IsSet(flags.NetworkFlagName) &&
(ctx.IsSet(AsteriscRollupConfigFlag.Name) || ctx.IsSet(AsteriscL2GenesisFlag.Name)) { (RollupConfigFlag.IsSet(ctx, traceType) || L2GenesisFlag.IsSet(ctx, traceType)) {
return fmt.Errorf("flag %v can not be used with %v and %v",
flags.NetworkFlagName, AsteriscRollupConfigFlag.Name, AsteriscL2GenesisFlag.Name)
}
if ctx.IsSet(AsteriscNetworkFlag.Name) &&
(ctx.IsSet(AsteriscRollupConfigFlag.Name) || ctx.IsSet(AsteriscL2GenesisFlag.Name)) {
return fmt.Errorf("flag %v can not be used with %v and %v", return fmt.Errorf("flag %v can not be used with %v and %v",
AsteriscNetworkFlag.Name, AsteriscRollupConfigFlag.Name, AsteriscL2GenesisFlag.Name) flags.NetworkFlagName, RollupConfigFlag.SourceFlagName(ctx, traceType), L2GenesisFlag.SourceFlagName(ctx, traceType))
} }
if !ctx.IsSet(AsteriscBinFlag.Name) { if !ctx.IsSet(AsteriscBinFlag.Name) {
return fmt.Errorf("flag %s is required", AsteriscBinFlag.Name) return fmt.Errorf("flag %s is required", AsteriscBinFlag.Name)
...@@ -356,27 +313,27 @@ func CheckAsteriscBaseFlags(ctx *cli.Context) error { ...@@ -356,27 +313,27 @@ func CheckAsteriscBaseFlags(ctx *cli.Context) error {
} }
func CheckAsteriscFlags(ctx *cli.Context) error { func CheckAsteriscFlags(ctx *cli.Context) error {
if err := CheckAsteriscBaseFlags(ctx); err != nil { if err := CheckAsteriscBaseFlags(ctx, types.TraceTypeAsterisc); err != nil {
return err return err
} }
if !ctx.IsSet(AsteriscServerFlag.Name) { if !ctx.IsSet(AsteriscServerFlag.Name) {
return fmt.Errorf("flag %s is required", AsteriscServerFlag.Name) return fmt.Errorf("flag %s is required", AsteriscServerFlag.Name)
} }
if !PreStatesURLFlag.IsSet(ctx, types.TraceTypeAsterisc) && !ctx.IsSet(AsteriscPreStateFlag.Name) { if !PreStatesURLFlag.IsSet(ctx, types.TraceTypeAsterisc) && !ctx.IsSet(AsteriscPreStateFlag.Name) {
return fmt.Errorf("flag %s or %s is required", PreStatesURLFlag.DefaultName(), AsteriscPreStateFlag.Name) return fmt.Errorf("flag %s or %s is required", PreStatesURLFlag.EitherFlagName(types.TraceTypeAsterisc), AsteriscPreStateFlag.Name)
} }
return nil return nil
} }
func CheckAsteriscKonaFlags(ctx *cli.Context) error { func CheckAsteriscKonaFlags(ctx *cli.Context) error {
if err := CheckAsteriscBaseFlags(ctx); err != nil { if err := CheckAsteriscBaseFlags(ctx, types.TraceTypeAsteriscKona); err != nil {
return err return err
} }
if !ctx.IsSet(AsteriscKonaServerFlag.Name) { if !ctx.IsSet(AsteriscKonaServerFlag.Name) {
return fmt.Errorf("flag %s is required", AsteriscKonaServerFlag.Name) return fmt.Errorf("flag %s is required", AsteriscKonaServerFlag.Name)
} }
if !PreStatesURLFlag.IsSet(ctx, types.TraceTypeAsteriscKona) && !ctx.IsSet(AsteriscKonaPreStateFlag.Name) { if !PreStatesURLFlag.IsSet(ctx, types.TraceTypeAsteriscKona) && !ctx.IsSet(AsteriscKonaPreStateFlag.Name) {
return fmt.Errorf("flag %s or %s is required", PreStatesURLFlag.DefaultName(), AsteriscKonaPreStateFlag.Name) return fmt.Errorf("flag %s or %s is required", PreStatesURLFlag.EitherFlagName(types.TraceTypeAsteriscKona), AsteriscKonaPreStateFlag.Name)
} }
return nil return nil
} }
...@@ -387,8 +344,7 @@ func CheckRequired(ctx *cli.Context, traceTypes []types.TraceType) error { ...@@ -387,8 +344,7 @@ func CheckRequired(ctx *cli.Context, traceTypes []types.TraceType) error {
return fmt.Errorf("flag %s is required", f.Names()[0]) return fmt.Errorf("flag %s is required", f.Names()[0])
} }
} }
// CannonL2Flag is checked because it is an alias with L2EthRpcFlag if !ctx.IsSet(L2EthRpcFlag.Name) {
if !ctx.IsSet(CannonL2Flag.Name) && !ctx.IsSet(L2EthRpcFlag.Name) {
return fmt.Errorf("flag %s is required", L2EthRpcFlag.Name) return fmt.Errorf("flag %s is required", L2EthRpcFlag.Name)
} }
for _, traceType := range traceTypes { for _, traceType := range traceTypes {
...@@ -427,21 +383,6 @@ func parseTraceTypes(ctx *cli.Context) ([]types.TraceType, error) { ...@@ -427,21 +383,6 @@ func parseTraceTypes(ctx *cli.Context) ([]types.TraceType, error) {
return traceTypes, nil return traceTypes, nil
} }
func getL2Rpc(ctx *cli.Context, logger log.Logger) (string, error) {
if ctx.IsSet(CannonL2Flag.Name) && ctx.IsSet(L2EthRpcFlag.Name) {
return "", fmt.Errorf("flag %v and %v must not be both set", CannonL2Flag.Name, L2EthRpcFlag.Name)
}
l2Rpc := ""
if ctx.IsSet(CannonL2Flag.Name) {
logger.Warn(fmt.Sprintf("flag %v is deprecated, please use %v", CannonL2Flag.Name, L2EthRpcFlag.Name))
l2Rpc = ctx.String(CannonL2Flag.Name)
}
if ctx.IsSet(L2EthRpcFlag.Name) {
l2Rpc = ctx.String(L2EthRpcFlag.Name)
}
return l2Rpc, nil
}
func FactoryAddress(ctx *cli.Context) (common.Address, error) { func FactoryAddress(ctx *cli.Context) (common.Address, error) {
// Use FactoryAddressFlag in preference to Network. Allows overriding the default dispute game factory. // Use FactoryAddressFlag in preference to Network. Allows overriding the default dispute game factory.
if ctx.IsSet(FactoryAddressFlag.Name) { if ctx.IsSet(FactoryAddressFlag.Name) {
...@@ -515,44 +456,34 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro ...@@ -515,44 +456,34 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro
claimants = append(claimants, claimant) claimants = append(claimants, claimant)
} }
} }
var cannonPreStatesURL *url.URL
if PreStatesURLFlag.IsSet(ctx, types.TraceTypeCannon) { getPrestatesUrl := func(traceType types.TraceType) (*url.URL, error) {
val := PreStatesURLFlag.String(ctx, types.TraceTypeCannon) var preStatesURL *url.URL
cannonPreStatesURL, err = url.Parse(val) if PreStatesURLFlag.IsSet(ctx, traceType) {
val := PreStatesURLFlag.String(ctx, traceType)
preStatesURL, err = url.Parse(val)
if err != nil { if err != nil {
return nil, fmt.Errorf("invalid %v (%v): %w", PreStatesURLFlag.SourceFlagName(ctx, types.TraceTypeCannon), val, err) return nil, fmt.Errorf("invalid %v (%v): %w", PreStatesURLFlag.SourceFlagName(ctx, traceType), val, err)
} }
} }
var asteriscPreStatesURL *url.URL return preStatesURL, nil
if PreStatesURLFlag.IsSet(ctx, types.TraceTypeAsterisc) {
val := PreStatesURLFlag.String(ctx, types.TraceTypeAsterisc)
asteriscPreStatesURL, err = url.Parse(val)
if err != nil {
return nil, fmt.Errorf("invalid %v (%v): %w", PreStatesURLFlag.SourceFlagName(ctx, types.TraceTypeAsterisc), val, err)
}
} }
var asteriscKonaPreStatesURL *url.URL cannonPreStatesURL, err := getPrestatesUrl(types.TraceTypeCannon)
if PreStatesURLFlag.IsSet(ctx, types.TraceTypeAsteriscKona) {
val := PreStatesURLFlag.String(ctx, types.TraceTypeAsteriscKona)
asteriscKonaPreStatesURL, err = url.Parse(val)
if err != nil { if err != nil {
return nil, fmt.Errorf("invalid %v (%v): %w", PreStatesURLFlag.SourceFlagName(ctx, types.TraceTypeAsteriscKona), val, err) return nil, err
}
} }
l2Rpc, err := getL2Rpc(ctx, logger) asteriscPreStatesURL, err := getPrestatesUrl(types.TraceTypeAsterisc)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cannonNetwork := ctx.String(CannonNetworkFlag.Name) asteriscKonaPreStatesURL, err := getPrestatesUrl(types.TraceTypeAsteriscKona)
if ctx.IsSet(flags.NetworkFlagName) { if err != nil {
cannonNetwork = ctx.String(flags.NetworkFlagName) return nil, err
}
asteriscNetwork := ctx.String(AsteriscNetworkFlag.Name)
if ctx.IsSet(flags.NetworkFlagName) {
asteriscNetwork = ctx.String(flags.NetworkFlagName)
} }
network := ctx.String(flags.NetworkFlagName)
l1EthRpc := ctx.String(L1EthRpcFlag.Name) l1EthRpc := ctx.String(L1EthRpcFlag.Name)
l1Beacon := ctx.String(L1BeaconFlag.Name) l1Beacon := ctx.String(L1BeaconFlag.Name)
l2Rpc := ctx.String(L2EthRpcFlag.Name)
return &config.Config{ return &config.Config{
// Required Flags // Required Flags
L1EthRpc: l1EthRpc, L1EthRpc: l1EthRpc,
...@@ -574,10 +505,10 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro ...@@ -574,10 +505,10 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro
L2: l2Rpc, L2: l2Rpc,
VmBin: ctx.String(CannonBinFlag.Name), VmBin: ctx.String(CannonBinFlag.Name),
Server: ctx.String(CannonServerFlag.Name), Server: ctx.String(CannonServerFlag.Name),
Network: cannonNetwork, Network: network,
L2Custom: ctx.Bool(CannonL2CustomFlag.Name), L2Custom: ctx.Bool(CannonL2CustomFlag.Name),
RollupConfigPath: ctx.String(CannonRollupConfigFlag.Name), RollupConfigPath: RollupConfigFlag.String(ctx, types.TraceTypeCannon),
L2GenesisPath: ctx.String(CannonL2GenesisFlag.Name), L2GenesisPath: L2GenesisFlag.String(ctx, types.TraceTypeCannon),
SnapshotFreq: ctx.Uint(CannonSnapshotFreqFlag.Name), SnapshotFreq: ctx.Uint(CannonSnapshotFreqFlag.Name),
InfoFreq: ctx.Uint(CannonInfoFreqFlag.Name), InfoFreq: ctx.Uint(CannonInfoFreqFlag.Name),
DebugInfo: true, DebugInfo: true,
...@@ -593,9 +524,9 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro ...@@ -593,9 +524,9 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro
L2: l2Rpc, L2: l2Rpc,
VmBin: ctx.String(AsteriscBinFlag.Name), VmBin: ctx.String(AsteriscBinFlag.Name),
Server: ctx.String(AsteriscServerFlag.Name), Server: ctx.String(AsteriscServerFlag.Name),
Network: asteriscNetwork, Network: network,
RollupConfigPath: ctx.String(AsteriscRollupConfigFlag.Name), RollupConfigPath: RollupConfigFlag.String(ctx, types.TraceTypeAsterisc),
L2GenesisPath: ctx.String(AsteriscL2GenesisFlag.Name), L2GenesisPath: L2GenesisFlag.String(ctx, types.TraceTypeAsterisc),
SnapshotFreq: ctx.Uint(AsteriscSnapshotFreqFlag.Name), SnapshotFreq: ctx.Uint(AsteriscSnapshotFreqFlag.Name),
InfoFreq: ctx.Uint(AsteriscInfoFreqFlag.Name), InfoFreq: ctx.Uint(AsteriscInfoFreqFlag.Name),
BinarySnapshots: true, BinarySnapshots: true,
...@@ -609,9 +540,9 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro ...@@ -609,9 +540,9 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro
L2: l2Rpc, L2: l2Rpc,
VmBin: ctx.String(AsteriscBinFlag.Name), VmBin: ctx.String(AsteriscBinFlag.Name),
Server: ctx.String(AsteriscKonaServerFlag.Name), Server: ctx.String(AsteriscKonaServerFlag.Name),
Network: asteriscNetwork, Network: network,
RollupConfigPath: ctx.String(AsteriscRollupConfigFlag.Name), RollupConfigPath: RollupConfigFlag.String(ctx, types.TraceTypeAsteriscKona),
L2GenesisPath: ctx.String(AsteriscL2GenesisFlag.Name), L2GenesisPath: L2GenesisFlag.String(ctx, types.TraceTypeAsteriscKona),
SnapshotFreq: ctx.Uint(AsteriscSnapshotFreqFlag.Name), SnapshotFreq: ctx.Uint(AsteriscSnapshotFreqFlag.Name),
InfoFreq: ctx.Uint(AsteriscInfoFreqFlag.Name), InfoFreq: ctx.Uint(AsteriscInfoFreqFlag.Name),
BinarySnapshots: true, BinarySnapshots: true,
......
op-challenger/flags/vm_flag.go
View file @ 6f0d98c5
...@@ -34,7 +34,7 @@ func (f *VMFlag) Flags() []cli.Flag { ...@@ -34,7 +34,7 @@ func (f *VMFlag) Flags() []cli.Flag {
defaultEnvVar := opservice.FlagNameToEnvVarName(f.name, f.envVarPrefix) defaultEnvVar := opservice.FlagNameToEnvVarName(f.name, f.envVarPrefix)
flags = append(flags, f.flagCreator(f.name, []string{defaultEnvVar}, "")) flags = append(flags, f.flagCreator(f.name, []string{defaultEnvVar}, ""))
for _, vm := range f.vms { for _, vm := range f.vms {
name := f.flagName(vm) name := f.TraceSpecificFlagName(vm)
envVar := opservice.FlagNameToEnvVarName(name, f.envVarPrefix) envVar := opservice.FlagNameToEnvVarName(name, f.envVarPrefix)
flags = append(flags, f.flagCreator(name, []string{envVar}, fmt.Sprintf("(%v trace type only)", vm))) flags = append(flags, f.flagCreator(name, []string{envVar}, fmt.Sprintf("(%v trace type only)", vm)))
} }
...@@ -46,11 +46,11 @@ func (f *VMFlag) DefaultName() string { ...@@ -46,11 +46,11 @@ func (f *VMFlag) DefaultName() string {
} }
func (f *VMFlag) IsSet(ctx *cli.Context, vm types.TraceType) bool { func (f *VMFlag) IsSet(ctx *cli.Context, vm types.TraceType) bool {
return ctx.IsSet(f.flagName(vm)) || ctx.IsSet(f.name) return ctx.IsSet(f.TraceSpecificFlagName(vm)) || ctx.IsSet(f.name)
} }
func (f *VMFlag) String(ctx *cli.Context, vm types.TraceType) string { func (f *VMFlag) String(ctx *cli.Context, vm types.TraceType) string {
val := ctx.String(f.flagName(vm)) val := ctx.String(f.TraceSpecificFlagName(vm))
if val == "" { if val == "" {
val = ctx.String(f.name) val = ctx.String(f.name)
} }
...@@ -58,13 +58,17 @@ func (f *VMFlag) String(ctx *cli.Context, vm types.TraceType) string { ...@@ -58,13 +58,17 @@ func (f *VMFlag) String(ctx *cli.Context, vm types.TraceType) string {
} }
func (f *VMFlag) SourceFlagName(ctx *cli.Context, vm types.TraceType) string { func (f *VMFlag) SourceFlagName(ctx *cli.Context, vm types.TraceType) string {
vmFlag := f.flagName(vm) vmFlag := f.TraceSpecificFlagName(vm)
if ctx.IsSet(vmFlag) { if ctx.IsSet(vmFlag) {
return vmFlag return vmFlag
} }
return f.name return f.name
} }
func (f *VMFlag) flagName(vm types.TraceType) string { func (f *VMFlag) EitherFlagName(vm types.TraceType) string {
return fmt.Sprintf("%s/%s", f.DefaultName(), f.TraceSpecificFlagName(vm))
}
func (f *VMFlag) TraceSpecificFlagName(vm types.TraceType) string {
return fmt.Sprintf("%v-%v", vm, f.name) return fmt.Sprintf("%v-%v", vm, f.name)
} }
op-challenger/game/fault/trace/vm/executor.go
View file @ 6f0d98c5
...@@ -2,6 +2,7 @@ package vm ...@@ -2,6 +2,7 @@ package vm
import ( import (
"context" "context"
"errors"
"fmt" "fmt"
"math" "math"
"os" "os"
...@@ -10,6 +11,7 @@ import ( ...@@ -10,6 +11,7 @@ import (
"strings" "strings"
"time" "time"
"github.com/ethereum-optimism/optimism/op-node/chaincfg"
"github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/log"
...@@ -23,6 +25,17 @@ const ( ...@@ -23,6 +25,17 @@ const (
debugFilename = "debug-info.json" debugFilename = "debug-info.json"
) )
var (
ErrMissingBin = errors.New("missing bin")
ErrMissingServer = errors.New("missing server")
ErrMissingRollupConfig = errors.New("missing network or rollup config path")
ErrMissingL2Genesis = errors.New("missing network or l2 genesis path")
ErrNetworkAndRollupConfig = errors.New("only specify one of network or rollup config path")
ErrNetworkAndL2Genesis = errors.New("only specify one of network or l2 genesis path")
ErrNetworkUnknown = errors.New("unknown network")
)
type Metricer = metrics.TypedVmMetricer type Metricer = metrics.TypedVmMetricer
type Config struct { type Config struct {
...@@ -45,6 +58,45 @@ type Config struct { ...@@ -45,6 +58,45 @@ type Config struct {
L2GenesisPath string L2GenesisPath string
} }
func (c *Config) Check() error {
if c.VmBin == "" {
return ErrMissingBin
}
if c.Server == "" {
return ErrMissingServer
}
if _, err := os.Stat(c.VmBin); err != nil {
return fmt.Errorf("%w: %w", ErrMissingBin, err)
}
if _, err := os.Stat(c.Server); err != nil {
return fmt.Errorf("%w: %w", ErrMissingServer, err)
}
if c.Network == "" {
if c.RollupConfigPath == "" {
return ErrMissingRollupConfig
}
if c.L2GenesisPath == "" {
return ErrMissingL2Genesis
}
} else {
if c.RollupConfigPath != "" {
return ErrNetworkAndRollupConfig
}
if c.L2GenesisPath != "" {
return ErrNetworkAndL2Genesis
}
if ch := chaincfg.ChainByName(c.Network); ch == nil {
// Check if this looks like a chain ID that could be a custom chain configuration.
if _, err := strconv.ParseUint(c.Network, 10, 32); err != nil {
return fmt.Errorf("%w: %v", ErrNetworkUnknown, c.Network)
}
}
}
return nil
}
type OracleServerExecutor interface { type OracleServerExecutor interface {
OracleCommand(cfg Config, dataDir string, inputs utils.LocalGameInputs) ([]string, error) OracleCommand(cfg Config, dataDir string, inputs utils.LocalGameInputs) ([]string, error)
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment