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
Hide 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 (
l1EthRpc = "http://example.com:8545"
l1Beacon = "http://example.com:9000"
gameFactoryAddressValue = "0xbb00000000000000000000000000000000000000"
cannonNetwork = "op-mainnet"
network = "op-mainnet"
testNetwork = "op-sepolia"
l2EthRpc = "http://example.com:9545"
cannonBin = "./bin/cannon"
......@@ -31,7 +31,6 @@ var (
cannonPreState = "./pre.json"
datadir = "./test_data"
rollupRpc = "http://example.com:8555"
asteriscNetwork = "op-mainnet"
asteriscBin = "./bin/asterisc"
asteriscServer = "./bin/op-program"
asteriscPreState = "./pre.json"
......@@ -294,7 +293,7 @@ func TestAsteriscOpProgramRequiredArgs(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) {
......@@ -319,7 +318,7 @@ func TestAsteriscOpProgramRequiredArgs(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) {
......@@ -338,7 +337,7 @@ func TestAsteriscOpProgramRequiredArgs(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) {
......@@ -371,7 +370,7 @@ func TestAsteriscKonaRequiredArgs(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) {
......@@ -386,7 +385,7 @@ func TestAsteriscKonaRequiredArgs(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) {
......@@ -411,7 +410,7 @@ func TestAsteriscKonaRequiredArgs(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) {
......@@ -448,19 +447,10 @@ func TestAsteriscBaseRequiredArgs(t *testing.T) {
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) {
cfg := configForArgs(t, addRequiredArgs(traceType))
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) {
......@@ -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(
t,
"flag asterisc-network, network or asterisc-rollup-config and asterisc-l2-genesis is required",
addRequiredArgsExcept(traceType, "--asterisc-network"))
fmt.Sprintf("flag network or rollup-config/%s-rollup-config and l2-genesis/%s-l2-genesis is required", traceType, traceType),
addRequiredArgsExcept(traceType, "--network"))
verifyArgsInvalid(
t,
"flag asterisc-network, network or asterisc-rollup-config and asterisc-l2-genesis is required",
addRequiredArgsExcept(traceType, "--asterisc-network", "--asterisc-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) {
fmt.Sprintf("flag network or rollup-config/%s-rollup-config and l2-genesis/%s-l2-genesis is required", traceType, traceType),
addRequiredArgsExcept(traceType, "--network", "--rollup-config=rollup.json"))
verifyArgsInvalid(
t,
"flag asterisc-network can not be used with asterisc-rollup-config and asterisc-l2-genesis",
addRequiredArgsExcept(traceType, "--asterisc-network",
"--asterisc-network", asteriscNetwork, "--asterisc-rollup-config=rollup.json"))
fmt.Sprintf("flag network or rollup-config/%s-rollup-config and l2-genesis/%s-l2-genesis is required", traceType, traceType),
addRequiredArgsExcept(traceType, "--network", "--l2-genesis=gensis.json"))
})
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(
t,
"flag network can not be used with asterisc-rollup-config and asterisc-l2-genesis",
toArgList(args))
"flag network can not be used with rollup-config and l2-genesis",
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) {
configForArgs(t, addRequiredArgsExcept(types.TraceTypeAlphabet, "--asterisc-network"))
configForArgs(t, addRequiredArgsExcept(types.TraceTypeAlphabet, "--network"))
})
t.Run("NotRequiredWhenRollupAndGenesIsSpecified", func(t *testing.T) {
configForArgs(t, addRequiredArgsExcept(traceType, "--asterisc-network",
"--asterisc-rollup-config=rollup.json", "--asterisc-l2-genesis=genesis.json"))
t.Run("NotRequiredWhenRollupAndGenesisSpecified", func(t *testing.T) {
configForArgs(t, addRequiredArgsExcept(traceType, "--network",
"--rollup-config=rollup.json", "--l2-genesis=genesis.json"))
})
t.Run("NotRequiredWhenNetworkSpecified", func(t *testing.T) {
args := requiredArgs(traceType)
delete(args, "--asterisc-network")
delete(args, "--network")
delete(args, "--game-factory-address")
args["--network"] = "op-sepolia"
cfg := configForArgs(t, toArgList(args))
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) {
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)
})
})
......@@ -569,18 +540,18 @@ func TestAsteriscBaseRequiredArgs(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)
})
})
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) {
configForArgs(t, addRequiredArgsExcept(types.TraceTypeAlphabet, "--asterisc-l2-genesis"))
configForArgs(t, addRequiredArgsExcept(types.TraceTypeAlphabet, "--l2-genesis"))
})
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)
})
})
......@@ -593,11 +564,6 @@ func TestAlphabetRequiredArgs(t *testing.T) {
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) {
cfg := configForArgs(t, addRequiredArgs(types.TraceTypeAlphabet))
require.Equal(t, l2EthRpc, cfg.L2Rpc)
......@@ -644,7 +610,7 @@ func TestCannonRequiredArgs(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) {
......@@ -659,7 +625,7 @@ func TestCannonRequiredArgs(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) {
......@@ -684,7 +650,7 @@ func TestCannonRequiredArgs(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) {
......@@ -702,11 +668,6 @@ func TestCannonRequiredArgs(t *testing.T) {
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) {
cfg := configForArgs(t, addRequiredArgs(traceType))
require.Equal(t, l2EthRpc, cfg.L2Rpc)
......@@ -750,31 +711,30 @@ func TestCannonRequiredArgs(t *testing.T) {
t.Run(fmt.Sprintf("TestRequireEitherCannonNetworkOrRollupAndGenesis-%v", traceType), func(t *testing.T) {
verifyArgsInvalid(
t,
"flag cannon-network, network or cannon-rollup-config and cannon-l2-genesis is required",
addRequiredArgsExcept(traceType, "--cannon-network"))
"flag network or rollup-config/cannon-rollup-config and l2-genesis/cannon-l2-genesis is required",
addRequiredArgsExcept(traceType, "--network"))
verifyArgsInvalid(
t,
"flag cannon-network, network or cannon-rollup-config and cannon-l2-genesis is required",
addRequiredArgsExcept(traceType, "--cannon-network", "--cannon-rollup-config=rollup.json"))
"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 cannon-network, network or cannon-rollup-config and cannon-l2-genesis is required",
addRequiredArgsExcept(traceType, "--cannon-network", "--cannon-l2-genesis=gensis.json"))
"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("TestMustNotSpecifyCannonNetworkAndRollup-%v", traceType), func(t *testing.T) {
t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) {
verifyArgsInvalid(
t,
"flag cannon-network can not be used with cannon-rollup-config, cannon-l2-genesis or cannon-l2-custom",
addRequiredArgsExcept(traceType, "--cannon-network",
"--cannon-network", cannonNetwork, "--cannon-rollup-config=rollup.json"))
"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, "--cannon-network")
delete(args, "--network")
delete(args, "--game-factory-address")
args["--network"] = cannonNetwork
args["--network"] = network
args["--cannon-rollup-config"] = "rollup.json"
args["--cannon-l2-genesis"] = "gensis.json"
args["--cannon-l2-custom"] = "true"
......@@ -784,38 +744,20 @@ func TestCannonRequiredArgs(t *testing.T) {
toArgList(args))
})
t.Run(fmt.Sprintf("TestCannonNetwork-%v", traceType), func(t *testing.T) {
t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
configForArgs(t, addRequiredArgsExcept(types.TraceTypeAlphabet, "--cannon-network"))
})
t.Run(fmt.Sprintf("TestNetwork-%v", traceType), 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"))
})
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) {
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)
})
})
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-l2-genesis=genesis.json",
"--cannon-l2-custom"))
......@@ -828,7 +770,7 @@ func TestCannonRequiredArgs(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)
})
})
......@@ -839,7 +781,7 @@ func TestCannonRequiredArgs(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)
})
})
......@@ -1050,21 +992,21 @@ func requiredArgs(traceType types.TraceType) map[string]string {
}
func addRequiredCannonArgs(args map[string]string) {
args["--cannon-network"] = cannonNetwork
args["--network"] = network
args["--cannon-bin"] = cannonBin
args["--cannon-server"] = cannonServer
args["--cannon-prestate"] = cannonPreState
}
func addRequiredAsteriscArgs(args map[string]string) {
args["--asterisc-network"] = asteriscNetwork
args["--network"] = network
args["--asterisc-bin"] = asteriscBin
args["--asterisc-server"] = asteriscServer
args["--asterisc-prestate"] = asteriscPreState
}
func addRequiredAsteriscKonaArgs(args map[string]string) {
args["--asterisc-network"] = asteriscNetwork
args["--network"] = network
args["--asterisc-bin"] = asteriscBin
args["--asterisc-kona-server"] = asteriscServer
args["--asterisc-kona-prestate"] = asteriscPreState
......
op-challenger/config/config.go
View file @ 6f0d98c5
......@@ -4,15 +4,12 @@ import (
"errors"
"fmt"
"net/url"
"os"
"runtime"
"slices"
"strconv"
"time"
"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-node/chaincfg"
opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
"github.com/ethereum-optimism/optimism/op-service/oppprof"
"github.com/ethereum-optimism/optimism/op-service/txmgr"
......@@ -24,42 +21,22 @@ var (
ErrMissingDatadir = errors.New("missing datadir")
ErrMaxConcurrencyZero = errors.New("max concurrency must not be 0")
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")
ErrMissingL1EthRPC = errors.New("missing l1 eth rpc url")
ErrMissingL1Beacon = errors.New("missing l1 beacon url")
ErrMissingGameFactoryAddress = errors.New("missing game factory address")
ErrMissingCannonSnapshotFreq = errors.New("missing cannon snapshot 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")
ErrMissingAsteriscBin = errors.New("missing asterisc bin")
ErrMissingAsteriscServer = errors.New("missing asterisc server")
ErrMissingRollupRpc = errors.New("missing rollup rpc url")
ErrMissingAsteriscAbsolutePreState = errors.New("missing asterisc absolute pre-state")
ErrMissingAsteriscSnapshotFreq = errors.New("missing asterisc snapshot 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")
ErrMissingAsteriscKonaSnapshotFreq = errors.New("missing asterisc kona snapshot 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 (
......@@ -73,7 +50,7 @@ const (
// 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
// buffer to monitor games to ensure bonds are claimed.
DefaultGameWindow = time.Duration(28 * 24 * time.Hour)
DefaultGameWindow = 28 * 24 * time.Hour
DefaultMaxPendingTx = 10
)
......@@ -211,40 +188,8 @@ func (c Config) Check() error {
return ErrMaxConcurrencyZero
}
if c.TraceTypeEnabled(types.TraceTypeCannon) || c.TraceTypeEnabled(types.TraceTypePermissioned) {
if c.Cannon.VmBin == "" {
return ErrMissingCannonBin
}
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 err := c.Cannon.Check(); err != nil {
return fmt.Errorf("cannon: %w", err)
}
if c.CannonAbsolutePreState == "" && c.CannonAbsolutePreStateBaseURL == nil {
return ErrMissingCannonAbsolutePreState
......@@ -257,37 +202,8 @@ func (c Config) Check() error {
}
}
if c.TraceTypeEnabled(types.TraceTypeAsterisc) {
if c.Asterisc.VmBin == "" {
return ErrMissingAsteriscBin
}
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 err := c.Asterisc.Check(); err != nil {
return fmt.Errorf("asterisc: %w", err)
}
if c.AsteriscAbsolutePreState == "" && c.AsteriscAbsolutePreStateBaseURL == nil {
return ErrMissingAsteriscAbsolutePreState
......@@ -300,37 +216,8 @@ func (c Config) Check() error {
}
}
if c.TraceTypeEnabled(types.TraceTypeAsteriscKona) {
if c.AsteriscKona.VmBin == "" {
return ErrMissingAsteriscKonaBin
}
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 err := c.AsteriscKona.Check(); err != nil {
return fmt.Errorf("asterisc kona: %w", err)
}
if c.AsteriscKonaAbsolutePreState == "" && c.AsteriscKonaAbsolutePreStateBaseURL == nil {
return ErrMissingAsteriscKonaAbsolutePreState
......
op-challenger/config/config_test.go
View file @ 6f0d98c5
......@@ -8,6 +8,7 @@ import (
"runtime"
"testing"
"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/vm"
"github.com/ethereum/go-ethereum/common"
"github.com/stretchr/testify/require"
......@@ -175,13 +176,13 @@ func TestCannonRequiredArgs(t *testing.T) {
t.Run(fmt.Sprintf("TestCannonBinRequired-%v", traceType), func(t *testing.T) {
config := validConfig(t, traceType)
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) {
config := validConfig(t, traceType)
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) {
......@@ -240,7 +241,7 @@ func TestCannonRequiredArgs(t *testing.T) {
cfg.Cannon.Network = ""
cfg.Cannon.RollupConfigPath = ""
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) {
......@@ -248,7 +249,7 @@ func TestCannonRequiredArgs(t *testing.T) {
cfg.Cannon.Network = ""
cfg.Cannon.RollupConfigPath = "foo.json"
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) {
......@@ -256,7 +257,7 @@ func TestCannonRequiredArgs(t *testing.T) {
cfg.Cannon.Network = validCannonNetwork
cfg.Cannon.RollupConfigPath = "foo.json"
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) {
......@@ -264,13 +265,13 @@ func TestCannonRequiredArgs(t *testing.T) {
cfg.Cannon.Network = validCannonNetwork
cfg.Cannon.RollupConfigPath = ""
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) {
cfg := validConfig(t, traceType)
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) {
......@@ -282,7 +283,7 @@ func TestCannonRequiredArgs(t *testing.T) {
t.Run(fmt.Sprintf("TestNetworkInvalidWhenNotEntirelyNumeric-%v", traceType), func(t *testing.T) {
cfg := validConfig(t, traceType)
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) {
......@@ -293,13 +294,13 @@ func TestCannonRequiredArgs(t *testing.T) {
t.Run(fmt.Sprintf("TestVMBinExists-%v", traceType), func(t *testing.T) {
cfg := validConfig(t, traceType)
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) {
cfg := validConfig(t, traceType)
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) {
t.Run(fmt.Sprintf("TestAsteriscBinRequired-%v", traceType), func(t *testing.T) {
config := validConfig(t, traceType)
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) {
config := validConfig(t, traceType)
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) {
......@@ -376,7 +377,7 @@ func TestAsteriscRequiredArgs(t *testing.T) {
cfg.Asterisc.Network = ""
cfg.Asterisc.RollupConfigPath = ""
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) {
......@@ -384,7 +385,7 @@ func TestAsteriscRequiredArgs(t *testing.T) {
cfg.Asterisc.Network = ""
cfg.Asterisc.RollupConfigPath = "foo.json"
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) {
......@@ -392,7 +393,7 @@ func TestAsteriscRequiredArgs(t *testing.T) {
cfg.Asterisc.Network = validAsteriscNetwork
cfg.Asterisc.RollupConfigPath = "foo.json"
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) {
......@@ -400,13 +401,13 @@ func TestAsteriscRequiredArgs(t *testing.T) {
cfg.Asterisc.Network = validAsteriscNetwork
cfg.Asterisc.RollupConfigPath = ""
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) {
cfg := validConfig(t, traceType)
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) {
......@@ -417,13 +418,13 @@ func TestAsteriscRequiredArgs(t *testing.T) {
t.Run(fmt.Sprintf("TestVMBinExists-%v", traceType), func(t *testing.T) {
cfg := validConfig(t, traceType)
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) {
cfg := validConfig(t, traceType)
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) {
t.Run(fmt.Sprintf("TestAsteriscKonaBinRequired-%v", traceType), func(t *testing.T) {
config := validConfig(t, traceType)
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) {
config := validConfig(t, traceType)
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) {
......@@ -500,7 +501,7 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) {
cfg.AsteriscKona.Network = ""
cfg.AsteriscKona.RollupConfigPath = ""
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) {
......@@ -508,7 +509,7 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) {
cfg.AsteriscKona.Network = ""
cfg.AsteriscKona.RollupConfigPath = "foo.json"
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) {
......@@ -516,7 +517,7 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) {
cfg.AsteriscKona.Network = validAsteriscKonaNetwork
cfg.AsteriscKona.RollupConfigPath = "foo.json"
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) {
......@@ -524,13 +525,13 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) {
cfg.AsteriscKona.Network = validAsteriscKonaNetwork
cfg.AsteriscKona.RollupConfigPath = ""
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) {
cfg := validConfig(t, traceType)
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) {
......@@ -541,13 +542,13 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) {
t.Run(fmt.Sprintf("TestVMBinExists-%v", traceType), func(t *testing.T) {
cfg := validConfig(t, traceType)
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) {
cfg := validConfig(t, traceType)
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) {
// Require cannon specific args
cfg.Cannon.VmBin = ""
require.ErrorIs(t, cfg.Check(), ErrMissingCannonBin)
require.ErrorIs(t, cfg.Check(), vm.ErrMissingBin)
tmpDir := t.TempDir()
vmBin := filepath.Join(tmpDir, validCannonBin)
err := ensureExists(vmBin)
......@@ -649,9 +650,8 @@ func TestRequireConfigForMultipleTraceTypesForCannonAndAsterisc(t *testing.T) {
require.ErrorIs(t, cfg.Check(), ErrMissingAsteriscAbsolutePreState)
cfg.AsteriscAbsolutePreState = validAsteriscAbsolutePreState
// Require cannon specific args
cfg.Asterisc.Server = ""
require.ErrorIs(t, cfg.Check(), ErrMissingAsteriscServer)
require.ErrorIs(t, cfg.Check(), vm.ErrMissingServer)
server := filepath.Join(tmpDir, validAsteriscOpProgramBin)
err = ensureExists(server)
require.NoError(t, err)
......
op-challenger/flags/flags.go
View file @ 6f0d98c5
......@@ -81,7 +81,7 @@ var (
}
L2EthRpcFlag = &cli.StringFlag{
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"),
}
MaxPendingTransactionsFlag = &cli.Uint64Flag{
......@@ -110,11 +110,20 @@ var (
EnvVars: envVars,
}
})
CannonNetworkFlag = &cli.StringFlag{
Name: "cannon-network",
Usage: fmt.Sprintf("Deprecated: Use %v instead", flags.NetworkFlagName),
EnvVars: prefixEnvVars("CANNON_NETWORK"),
}
RollupConfigFlag = NewVMFlag("rollup-config", EnvVarPrefix, faultDisputeVMs, func(name string, envVars []string, traceTypeInfo string) cli.Flag {
return &cli.StringFlag{
Name: name,
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{
Name: "cannon-l2-custom",
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 (
Value: false,
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{
Name: "cannon-bin",
Usage: "Path to cannon executable to use when generating trace data (cannon trace type only)",
......@@ -148,11 +147,6 @@ var (
Usage: "Path to absolute prestate to use when generating trace data (cannon trace type only)",
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{
Name: "cannon-snapshot-freq",
Usage: "Frequency of cannon snapshots to generate in VM steps (cannon trace type only)",
......@@ -165,21 +159,6 @@ var (
EnvVars: prefixEnvVars("CANNON_INFO_FREQ"),
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{
Name: "asterisc-bin",
Usage: "Path to asterisc executable to use when generating trace data (asterisc trace type only)",
......@@ -256,19 +235,12 @@ var optionalFlags = []cli.Flag{
HTTPPollInterval,
AdditionalBondClaimants,
GameAllowlistFlag,
CannonNetworkFlag,
CannonL2CustomFlag,
CannonRollupConfigFlag,
CannonL2GenesisFlag,
CannonBinFlag,
CannonServerFlag,
CannonPreStateFlag,
CannonL2Flag,
CannonSnapshotFreqFlag,
CannonInfoFreqFlag,
AsteriscNetworkFlag,
AsteriscRollupConfigFlag,
AsteriscL2GenesisFlag,
AsteriscBinFlag,
AsteriscServerFlag,
AsteriscKonaServerFlag,
......@@ -284,6 +256,8 @@ var optionalFlags = []cli.Flag{
func init() {
optionalFlags = append(optionalFlags, oplog.CLIFlags(EnvVarPrefix)...)
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, opmetrics.CLIFlags(EnvVarPrefix)...)
optionalFlags = append(optionalFlags, oppprof.CLIFlags(EnvVarPrefix)...)
......@@ -295,27 +269,19 @@ func init() {
var Flags []cli.Flag
func CheckCannonFlags(ctx *cli.Context) error {
if ctx.IsSet(CannonNetworkFlag.Name) && ctx.IsSet(flags.NetworkFlagName) {
return fmt.Errorf("flag %v can not be used with %v", CannonNetworkFlag.Name, flags.NetworkFlagName)
}
if !ctx.IsSet(CannonNetworkFlag.Name) &&
!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) &&
!(RollupConfigFlag.IsSet(ctx, types.TraceTypeCannon) && L2GenesisFlag.IsSet(ctx, types.TraceTypeCannon)) {
return fmt.Errorf("flag %v or %v and %v is required",
flags.NetworkFlagName, RollupConfigFlag.EitherFlagName(types.TraceTypeCannon), L2GenesisFlag.EitherFlagName(types.TraceTypeCannon))
}
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)
flags.NetworkFlagName, RollupConfigFlag.SourceFlagName(ctx, types.TraceTypeCannon), L2GenesisFlag.SourceFlagName(ctx, types.TraceTypeCannon), 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",
CannonNetworkFlag.Name, CannonRollupConfigFlag.Name, CannonL2GenesisFlag.Name, CannonL2CustomFlag.Name)
}
if ctx.Bool(CannonL2CustomFlag.Name) && !(ctx.IsSet(CannonRollupConfigFlag.Name) && ctx.IsSet(CannonL2GenesisFlag.Name)) {
return fmt.Errorf("flag %v and %v must be set when %v is true", CannonRollupConfigFlag.Name, CannonL2GenesisFlag.Name, CannonL2CustomFlag.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",
RollupConfigFlag.EitherFlagName(types.TraceTypeCannon), L2GenesisFlag.EitherFlagName(types.TraceTypeCannon), CannonL2CustomFlag.Name)
}
if !ctx.IsSet(CannonBinFlag.Name) {
return fmt.Errorf("flag %s is required", CannonBinFlag.Name)
......@@ -324,30 +290,21 @@ func CheckCannonFlags(ctx *cli.Context) error {
return fmt.Errorf("flag %s is required", CannonServerFlag.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
}
func CheckAsteriscBaseFlags(ctx *cli.Context) error {
if ctx.IsSet(AsteriscNetworkFlag.Name) && ctx.IsSet(flags.NetworkFlagName) {
return fmt.Errorf("flag %v can not be used with %v", AsteriscNetworkFlag.Name, flags.NetworkFlagName)
}
if !ctx.IsSet(AsteriscNetworkFlag.Name) &&
!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)
func CheckAsteriscBaseFlags(ctx *cli.Context, traceType types.TraceType) error {
if !ctx.IsSet(flags.NetworkFlagName) &&
!(RollupConfigFlag.IsSet(ctx, traceType) && L2GenesisFlag.IsSet(ctx, traceType)) {
return fmt.Errorf("flag %v or %v and %v is required",
flags.NetworkFlagName, RollupConfigFlag.EitherFlagName(traceType), L2GenesisFlag.EitherFlagName(traceType))
}
if ctx.IsSet(flags.NetworkFlagName) &&
(ctx.IsSet(AsteriscRollupConfigFlag.Name) || ctx.IsSet(AsteriscL2GenesisFlag.Name)) {
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)) {
(RollupConfigFlag.IsSet(ctx, traceType) || L2GenesisFlag.IsSet(ctx, traceType)) {
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) {
return fmt.Errorf("flag %s is required", AsteriscBinFlag.Name)
......@@ -356,27 +313,27 @@ func CheckAsteriscBaseFlags(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
}
if !ctx.IsSet(AsteriscServerFlag.Name) {
return fmt.Errorf("flag %s is required", AsteriscServerFlag.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
}
func CheckAsteriscKonaFlags(ctx *cli.Context) error {
if err := CheckAsteriscBaseFlags(ctx); err != nil {
if err := CheckAsteriscBaseFlags(ctx, types.TraceTypeAsteriscKona); err != nil {
return err
}
if !ctx.IsSet(AsteriscKonaServerFlag.Name) {
return fmt.Errorf("flag %s is required", AsteriscKonaServerFlag.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
}
......@@ -387,8 +344,7 @@ func CheckRequired(ctx *cli.Context, traceTypes []types.TraceType) error {
return fmt.Errorf("flag %s is required", f.Names()[0])
}
}
// CannonL2Flag is checked because it is an alias with L2EthRpcFlag
if !ctx.IsSet(CannonL2Flag.Name) && !ctx.IsSet(L2EthRpcFlag.Name) {
if !ctx.IsSet(L2EthRpcFlag.Name) {
return fmt.Errorf("flag %s is required", L2EthRpcFlag.Name)
}
for _, traceType := range traceTypes {
......@@ -427,21 +383,6 @@ func parseTraceTypes(ctx *cli.Context) ([]types.TraceType, error) {
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) {
// Use FactoryAddressFlag in preference to Network. Allows overriding the default dispute game factory.
if ctx.IsSet(FactoryAddressFlag.Name) {
......@@ -515,44 +456,34 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro
claimants = append(claimants, claimant)
}
}
var cannonPreStatesURL *url.URL
if PreStatesURLFlag.IsSet(ctx, types.TraceTypeCannon) {
val := PreStatesURLFlag.String(ctx, types.TraceTypeCannon)
cannonPreStatesURL, err = url.Parse(val)
if err != nil {
return nil, fmt.Errorf("invalid %v (%v): %w", PreStatesURLFlag.SourceFlagName(ctx, types.TraceTypeCannon), val, err)
}
}
var asteriscPreStatesURL *url.URL
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
if PreStatesURLFlag.IsSet(ctx, types.TraceTypeAsteriscKona) {
val := PreStatesURLFlag.String(ctx, types.TraceTypeAsteriscKona)
asteriscKonaPreStatesURL, err = url.Parse(val)
if err != nil {
return nil, fmt.Errorf("invalid %v (%v): %w", PreStatesURLFlag.SourceFlagName(ctx, types.TraceTypeAsteriscKona), val, err)
getPrestatesUrl := func(traceType types.TraceType) (*url.URL, error) {
var preStatesURL *url.URL
if PreStatesURLFlag.IsSet(ctx, traceType) {
val := PreStatesURLFlag.String(ctx, traceType)
preStatesURL, err = url.Parse(val)
if err != nil {
return nil, fmt.Errorf("invalid %v (%v): %w", PreStatesURLFlag.SourceFlagName(ctx, traceType), val, err)
}
}
return preStatesURL, nil
}
l2Rpc, err := getL2Rpc(ctx, logger)
cannonPreStatesURL, err := getPrestatesUrl(types.TraceTypeCannon)
if err != nil {
return nil, err
}
cannonNetwork := ctx.String(CannonNetworkFlag.Name)
if ctx.IsSet(flags.NetworkFlagName) {
cannonNetwork = ctx.String(flags.NetworkFlagName)
asteriscPreStatesURL, err := getPrestatesUrl(types.TraceTypeAsterisc)
if err != nil {
return nil, err
}
asteriscNetwork := ctx.String(AsteriscNetworkFlag.Name)
if ctx.IsSet(flags.NetworkFlagName) {
asteriscNetwork = ctx.String(flags.NetworkFlagName)
asteriscKonaPreStatesURL, err := getPrestatesUrl(types.TraceTypeAsteriscKona)
if err != nil {
return nil, err
}
network := ctx.String(flags.NetworkFlagName)
l1EthRpc := ctx.String(L1EthRpcFlag.Name)
l1Beacon := ctx.String(L1BeaconFlag.Name)
l2Rpc := ctx.String(L2EthRpcFlag.Name)
return &config.Config{
// Required Flags
L1EthRpc: l1EthRpc,
......@@ -574,10 +505,10 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro
L2: l2Rpc,
VmBin: ctx.String(CannonBinFlag.Name),
Server: ctx.String(CannonServerFlag.Name),
Network: cannonNetwork,
Network: network,
L2Custom: ctx.Bool(CannonL2CustomFlag.Name),
RollupConfigPath: ctx.String(CannonRollupConfigFlag.Name),
L2GenesisPath: ctx.String(CannonL2GenesisFlag.Name),
RollupConfigPath: RollupConfigFlag.String(ctx, types.TraceTypeCannon),
L2GenesisPath: L2GenesisFlag.String(ctx, types.TraceTypeCannon),
SnapshotFreq: ctx.Uint(CannonSnapshotFreqFlag.Name),
InfoFreq: ctx.Uint(CannonInfoFreqFlag.Name),
DebugInfo: true,
......@@ -593,9 +524,9 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro
L2: l2Rpc,
VmBin: ctx.String(AsteriscBinFlag.Name),
Server: ctx.String(AsteriscServerFlag.Name),
Network: asteriscNetwork,
RollupConfigPath: ctx.String(AsteriscRollupConfigFlag.Name),
L2GenesisPath: ctx.String(AsteriscL2GenesisFlag.Name),
Network: network,
RollupConfigPath: RollupConfigFlag.String(ctx, types.TraceTypeAsterisc),
L2GenesisPath: L2GenesisFlag.String(ctx, types.TraceTypeAsterisc),
SnapshotFreq: ctx.Uint(AsteriscSnapshotFreqFlag.Name),
InfoFreq: ctx.Uint(AsteriscInfoFreqFlag.Name),
BinarySnapshots: true,
......@@ -609,9 +540,9 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro
L2: l2Rpc,
VmBin: ctx.String(AsteriscBinFlag.Name),
Server: ctx.String(AsteriscKonaServerFlag.Name),
Network: asteriscNetwork,
RollupConfigPath: ctx.String(AsteriscRollupConfigFlag.Name),
L2GenesisPath: ctx.String(AsteriscL2GenesisFlag.Name),
Network: network,
RollupConfigPath: RollupConfigFlag.String(ctx, types.TraceTypeAsteriscKona),
L2GenesisPath: L2GenesisFlag.String(ctx, types.TraceTypeAsteriscKona),
SnapshotFreq: ctx.Uint(AsteriscSnapshotFreqFlag.Name),
InfoFreq: ctx.Uint(AsteriscInfoFreqFlag.Name),
BinarySnapshots: true,
......
op-challenger/flags/vm_flag.go
View file @ 6f0d98c5
......@@ -34,7 +34,7 @@ func (f *VMFlag) Flags() []cli.Flag {
defaultEnvVar := opservice.FlagNameToEnvVarName(f.name, f.envVarPrefix)
flags = append(flags, f.flagCreator(f.name, []string{defaultEnvVar}, ""))
for _, vm := range f.vms {
name := f.flagName(vm)
name := f.TraceSpecificFlagName(vm)
envVar := opservice.FlagNameToEnvVarName(name, f.envVarPrefix)
flags = append(flags, f.flagCreator(name, []string{envVar}, fmt.Sprintf("(%v trace type only)", vm)))
}
......@@ -46,11 +46,11 @@ func (f *VMFlag) DefaultName() string {
}
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 {
val := ctx.String(f.flagName(vm))
val := ctx.String(f.TraceSpecificFlagName(vm))
if val == "" {
val = ctx.String(f.name)
}
......@@ -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 {
vmFlag := f.flagName(vm)
vmFlag := f.TraceSpecificFlagName(vm)
if ctx.IsSet(vmFlag) {
return vmFlag
}
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)
}
op-challenger/game/fault/trace/vm/executor.go
View file @ 6f0d98c5
......@@ -2,6 +2,7 @@ package vm
import (
"context"
"errors"
"fmt"
"math"
"os"
......@@ -10,6 +11,7 @@ import (
"strings"
"time"
"github.com/ethereum-optimism/optimism/op-node/chaincfg"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/log"
......@@ -23,6 +25,17 @@ const (
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 Config struct {
......@@ -45,6 +58,45 @@ type Config struct {
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 {
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