Merge pull request #7274 from ethereum-optimism/refcell/l2-consensus

feat(op-challenger): Rollup RPC Challenger Flag

op-challenger/cmd/main_test.go

@@ -24,6 +24,7 @@ var (
 	cannonPreState          = "./pre.json"
 	datadir                 = "./test_data"
 	cannonL2                = "http://example.com:9545"
+	rollupRpc               = "http://example.com:8555"
 	alphabetTrace           = "abcdefghijz"
 	agreeWithProposedOutput = "true"
 )
@@ -249,6 +250,25 @@ func TestDataDir(t *testing.T) {
 	})
 }
 
+func TestRollupRpc(t *testing.T) {
+	t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
+		configForArgs(t, addRequiredArgsExcept(config.TraceTypeAlphabet, "--rollup-rpc"))
+	})
+
+	t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
+		configForArgs(t, addRequiredArgsExcept(config.TraceTypeCannon, "--rollup-rpc"))
+	})
+
+	t.Run("RequiredForOutputCannonTrace", func(t *testing.T) {
+		verifyArgsInvalid(t, "flag rollup-rpc is required", addRequiredArgsExcept(config.TraceTypeOutputCannon, "--rollup-rpc"))
+	})
+
+	t.Run("Valid", func(t *testing.T) {
+		cfg := configForArgs(t, addRequiredArgs(config.TraceTypeOutputCannon))
+		require.Equal(t, rollupRpc, cfg.RollupRpc)
+	})
+}
+
 func TestCannonL2(t *testing.T) {
 	t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
 		configForArgs(t, addRequiredArgsExcept(config.TraceTypeAlphabet, "--cannon-l2"))
@@ -429,6 +449,9 @@ func requiredArgs(traceType config.TraceType) map[string]string {
 		args["--cannon-prestate"] = cannonPreState
 		args["--cannon-l2"] = cannonL2
 	}
+	if traceType == config.TraceTypeOutputCannon {
+		args["--rollup-rpc"] = rollupRpc
+	}
 	return args
 }
 

op-challenger/config/config.go

@@ -32,6 +32,7 @@ var (
 	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")
 )
 
 type TraceType string
@@ -107,6 +108,9 @@ type Config struct {
 	// Specific to the alphabet trace provider
 	AlphabetTrace string // String for the AlphabetTraceProvider
 
+	// Specific to the output cannon trace type
+	RollupRpc string
+
 	// Specific to the cannon trace provider
 	CannonBin              string // Path to the cannon executable to run when generating trace data
 	CannonServer           string // Path to the op-program executable that provides the pre-image oracle server
@@ -168,6 +172,11 @@ func (c Config) Check() error {
 	if c.MaxConcurrency == 0 {
 		return ErrMaxConcurrencyZero
 	}
+	if c.TraceType == TraceTypeOutputCannon {
+		if c.RollupRpc == "" {
+			return ErrMissingRollupRpc
+		}
+	}
 	if c.TraceType == TraceTypeCannon || c.TraceType == TraceTypeOutputCannon {
 		if c.CannonBin == "" {
 			return ErrMissingCannonBin

op-challenger/config/config_test.go

@@ -20,6 +20,7 @@ var (
 	validCannonAbsolutPreState = "pre.json"
 	validDatadir               = "/tmp/data"
 	validCannonL2              = "http://localhost:9545"
+	validRollupRpc             = "http://localhost:8555"
 	agreeWithProposedOutput    = true
 )
 
@@ -35,6 +36,9 @@ func validConfig(traceType TraceType) Config {
 		cfg.CannonL2 = validCannonL2
 		cfg.CannonNetwork = validCannonNetwork
 	}
+	if traceType == TraceTypeOutputCannon {
+		cfg.RollupRpc = validRollupRpc
+	}
 	return cfg
 }
 
@@ -125,6 +129,12 @@ func TestHttpPollInterval(t *testing.T) {
 	})
 }
 
+func TestRollupRpcRequired(t *testing.T) {
+	config := validConfig(TraceTypeOutputCannon)
+	config.RollupRpc = ""
+	require.ErrorIs(t, config.Check(), ErrMissingRollupRpc)
+}
+
 func TestCannonL2Required(t *testing.T) {
 	config := validConfig(TraceTypeCannon)
 	config.CannonL2 = ""

op-challenger/flags/flags.go

@@ -76,14 +76,22 @@ var (
 		EnvVars: prefixEnvVars("HTTP_POLL_INTERVAL"),
 		Value:   config.DefaultPollInterval,
 	}
+	RollupRpcFlag = &cli.StringFlag{
+		Name:    "rollup-rpc",
+		Usage:   "HTTP provider URL for the rollup node",
+		EnvVars: prefixEnvVars("ROLLUP_RPC"),
+	}
 	AlphabetFlag = &cli.StringFlag{
 		Name:    "alphabet",
 		Usage:   "Correct Alphabet Trace (alphabet trace type only)",
 		EnvVars: prefixEnvVars("ALPHABET"),
 	}
 	CannonNetworkFlag = &cli.StringFlag{
-		Name:    "cannon-network",
-		Usage:   fmt.Sprintf("Predefined network selection. Available networks: %s (cannon trace type only)", strings.Join(chaincfg.AvailableNetworks(), ", ")),
+		Name: "cannon-network",
+		Usage: fmt.Sprintf(
+			"Predefined network selection. Available networks: %s (cannon trace type only)",
+			strings.Join(chaincfg.AvailableNetworks(), ", "),
+		),
 		EnvVars: prefixEnvVars("CANNON_NETWORK"),
 	}
 	CannonRollupConfigFlag = &cli.StringFlag{
@@ -149,6 +157,7 @@ var requiredFlags = []cli.Flag{
 var optionalFlags = []cli.Flag{
 	MaxConcurrencyFlag,
 	HTTPPollInterval,
+	RollupRpcFlag,
 	AlphabetFlag,
 	GameAllowlistFlag,
 	CannonNetworkFlag,
@@ -221,6 +230,9 @@ func CheckRequired(ctx *cli.Context) error {
 		if err := CheckCannonFlags(ctx); err != nil {
 			return err
 		}
+		if !ctx.IsSet(RollupRpcFlag.Name) {
+			return fmt.Errorf("flag %s is required", RollupRpcFlag.Name)
+		}
 	default:
 		return fmt.Errorf("invalid trace type. must be one of %v", config.TraceTypes)
 	}
@@ -266,6 +278,7 @@ func NewConfigFromCLI(ctx *cli.Context) (*config.Config, error) {
 		GameWindow:              ctx.Duration(GameWindowFlag.Name),
 		MaxConcurrency:          maxConcurrency,
 		PollInterval:            ctx.Duration(HTTPPollInterval.Name),
+		RollupRpc:               ctx.String(RollupRpcFlag.Name),
 		AlphabetTrace:           ctx.String(AlphabetFlag.Name),
 		CannonNetwork:           ctx.String(CannonNetworkFlag.Name),
 		CannonRollupConfigPath:  ctx.String(CannonRollupConfigFlag.Name),