Merge pull request #6634 from ethereum-optimism/aj/cannon-network

op-challenger: Pass through network config to cannon

op-challenger/cmd/main_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/ethereum-optimism/optimism/op-challenger/config"
+	"github.com/ethereum-optimism/optimism/op-node/chaincfg"
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
@@ -15,6 +16,8 @@ import (
 var (
 	l1EthRpc                = "http://example.com:8545"
 	gameAddressValue        = "0xaa00000000000000000000000000000000000000"
+	cannonNetwork           = chaincfg.AvailableNetworks()[0]
+	otherCannonNetwork      = chaincfg.AvailableNetworks()[1]
 	cannonBin               = "./bin/cannon"
 	cannonServer            = "./bin/op-program"
 	cannonPreState          = "./pre.json"
@@ -226,6 +229,67 @@ func TestCannonSnapshotFreq(t *testing.T) {
 	})
 }
 
+func TestRequireEitherCannonNetworkOrRollupAndGenesis(t *testing.T) {
+	verifyArgsInvalid(
+		t,
+		"flag cannon-network or cannon-rollup-config and cannon-l2-genesis is required",
+		addRequiredArgsExcept(config.TraceTypeCannon, "--cannon-network"))
+	verifyArgsInvalid(
+		t,
+		"flag cannon-network or cannon-rollup-config and cannon-l2-genesis is required",
+		addRequiredArgsExcept(config.TraceTypeCannon, "--cannon-network", "--cannon-rollup-config=rollup.json"))
+	verifyArgsInvalid(
+		t,
+		"flag cannon-network or cannon-rollup-config and cannon-l2-genesis is required",
+		addRequiredArgsExcept(config.TraceTypeCannon, "--cannon-network", "--cannon-l2-genesis=gensis.json"))
+}
+
+func TestMustNotSpecifyNetworkAndRollup(t *testing.T) {
+	verifyArgsInvalid(
+		t,
+		"flag cannon-network can not be used with cannon-rollup-config and cannon-l2-genesis",
+		addRequiredArgsExcept(config.TraceTypeCannon, "--cannon-network",
+			"--cannon-network", cannonNetwork, "--cannon-rollup-config=rollup.json"))
+}
+
+func TestCannonNetwork(t *testing.T) {
+	t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
+		configForArgs(t, addRequiredArgsExcept(config.TraceTypeAlphabet, "--cannon-network"))
+	})
+
+	t.Run("NotRequiredWhenRollupAndGenesIsSpecified", func(t *testing.T) {
+		configForArgs(t, addRequiredArgsExcept(config.TraceTypeCannon, "--cannon-network",
+			"--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json"))
+	})
+
+	t.Run("Valid", func(t *testing.T) {
+		cfg := configForArgs(t, addRequiredArgsExcept(config.TraceTypeCannon, "--cannon-network", "--cannon-network", otherCannonNetwork))
+		require.Equal(t, otherCannonNetwork, cfg.CannonNetwork)
+	})
+}
+
+func TestCannonRollupConfig(t *testing.T) {
+	t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
+		configForArgs(t, addRequiredArgsExcept(config.TraceTypeAlphabet, "--cannon-rollup-config"))
+	})
+
+	t.Run("Valid", func(t *testing.T) {
+		cfg := configForArgs(t, addRequiredArgsExcept(config.TraceTypeCannon, "--cannon-network", "--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json"))
+		require.Equal(t, "rollup.json", cfg.CannonRollupConfigPath)
+	})
+}
+
+func TestCannonL2Genesis(t *testing.T) {
+	t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
+		configForArgs(t, addRequiredArgsExcept(config.TraceTypeAlphabet, "--cannon-l2-genesis"))
+	})
+
+	t.Run("Valid", func(t *testing.T) {
+		cfg := configForArgs(t, addRequiredArgsExcept(config.TraceTypeCannon, "--cannon-network", "--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json"))
+		require.Equal(t, "genesis.json", cfg.CannonL2GenesisPath)
+	})
+}
+
 func verifyArgsInvalid(t *testing.T, messageContains string, cliArgs []string) {
 	_, _, err := runWithArgs(cliArgs)
 	require.ErrorContains(t, err, messageContains)
@@ -273,6 +337,7 @@ func requiredArgs(traceType config.TraceType) map[string]string {
 	case config.TraceTypeAlphabet:
 		args["--alphabet"] = alphabetTrace
 	case config.TraceTypeCannon:
+		args["--cannon-network"] = cannonNetwork
 		args["--cannon-bin"] = cannonBin
 		args["--cannon-server"] = cannonServer
 		args["--cannon-prestate"] = cannonPreState

op-challenger/config/config.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/ethereum-optimism/optimism/op-node/chaincfg"
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
 	"github.com/ethereum/go-ethereum/common"
 )
@@ -18,8 +19,12 @@ var (
 	ErrMissingAlphabetTrace          = errors.New("missing alphabet trace")
 	ErrMissingL1EthRPC               = errors.New("missing l1 eth rpc url")
 	ErrMissingGameAddress            = errors.New("missing game address")
-	ErrMissingPreimageOracleAddress  = errors.New("missing pre-image oracle address")
 	ErrMissingCannonSnapshotFreq     = errors.New("missing cannon snapshot 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")
 )
 
 type TraceType string
@@ -73,6 +78,9 @@ type Config struct {
 	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
 	CannonAbsolutePreState string // File to load the absolute pre-state for Cannon traces from
+	CannonNetwork          string
+	CannonRollupConfigPath string
+	CannonL2GenesisPath    string
 	CannonDatadir          string // Cannon Data Directory
 	CannonL2               string // L2 RPC Url
 	CannonSnapshotFreq     uint   // Frequency of snapshots to create when executing cannon (in VM instructions)
@@ -119,6 +127,24 @@ func (c Config) Check() error {
 		if c.CannonServer == "" {
 			return ErrMissingCannonServer
 		}
+		if c.CannonNetwork == "" {
+			if c.CannonRollupConfigPath == "" {
+				return ErrMissingCannonRollupConfig
+			}
+			if c.CannonL2GenesisPath == "" {
+				return ErrMissingCannonL2Genesis
+			}
+		} else {
+			if c.CannonRollupConfigPath != "" {
+				return ErrCannonNetworkAndRollupConfig
+			}
+			if c.CannonL2GenesisPath != "" {
+				return ErrCannonNetworkAndL2Genesis
+			}
+			if _, ok := chaincfg.NetworksByName[c.CannonNetwork]; !ok {
+				return fmt.Errorf("%w: %v", ErrCannonNetworkUnknown, c.CannonNetwork)
+			}
+		}
 		if c.CannonAbsolutePreState == "" {
 			return ErrMissingCannonAbsolutePreState
 		}

op-challenger/config/config_test.go

@@ -14,6 +14,7 @@ var (
 	validAlphabetTrace         = "abcdefgh"
 	validCannonBin             = "./bin/cannon"
 	validCannonOpProgramBin    = "./bin/op-program"
+	validCannonNetwork         = "mainnet"
 	validCannonAbsolutPreState = "pre.json"
 	validCannonDatadir         = "/tmp/cannon"
 	validCannonL2              = "http://localhost:9545"
@@ -32,6 +33,7 @@ func validConfig(traceType TraceType) Config {
 		cfg.CannonAbsolutePreState = validCannonAbsolutPreState
 		cfg.CannonDatadir = validCannonDatadir
 		cfg.CannonL2 = validCannonL2
+		cfg.CannonNetwork = validCannonNetwork
 	}
 	return cfg
 }
@@ -110,3 +112,41 @@ func TestCannonSnapshotFreq(t *testing.T) {
 		require.ErrorIs(t, cfg.Check(), ErrMissingCannonSnapshotFreq)
 	})
 }
+
+func TestCannonNetworkOrRollupConfigRequired(t *testing.T) {
+	cfg := validConfig(TraceTypeCannon)
+	cfg.CannonNetwork = ""
+	cfg.CannonRollupConfigPath = ""
+	cfg.CannonL2GenesisPath = "genesis.json"
+	require.ErrorIs(t, cfg.Check(), ErrMissingCannonRollupConfig)
+}
+
+func TestCannonNetworkOrL2GenesisRequired(t *testing.T) {
+	cfg := validConfig(TraceTypeCannon)
+	cfg.CannonNetwork = ""
+	cfg.CannonRollupConfigPath = "foo.json"
+	cfg.CannonL2GenesisPath = ""
+	require.ErrorIs(t, cfg.Check(), ErrMissingCannonL2Genesis)
+}
+
+func TestMustNotSpecifyNetworkAndRollup(t *testing.T) {
+	cfg := validConfig(TraceTypeCannon)
+	cfg.CannonNetwork = validCannonNetwork
+	cfg.CannonRollupConfigPath = "foo.json"
+	cfg.CannonL2GenesisPath = ""
+	require.ErrorIs(t, cfg.Check(), ErrCannonNetworkAndRollupConfig)
+}
+
+func TestMustNotSpecifyNetworkAndL2Genesis(t *testing.T) {
+	cfg := validConfig(TraceTypeCannon)
+	cfg.CannonNetwork = validCannonNetwork
+	cfg.CannonRollupConfigPath = ""
+	cfg.CannonL2GenesisPath = "foo.json"
+	require.ErrorIs(t, cfg.Check(), ErrCannonNetworkAndL2Genesis)
+}
+
+func TestNetworkMustBeValid(t *testing.T) {
+	cfg := validConfig(TraceTypeCannon)
+	cfg.CannonNetwork = "unknown"
+	require.ErrorIs(t, cfg.Check(), ErrCannonNetworkUnknown)
+}

op-challenger/fault/cannon/executor.go

@@ -4,11 +4,13 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"math"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"regexp"
 	"strconv"
+	"strings"
 
 	"github.com/ethereum-optimism/optimism/op-challenger/config"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
@@ -17,7 +19,7 @@ import (
 
 const (
 	snapsDir     = "snapshots"
-	preimagesDir = "snapshots"
+	preimagesDir = "preimages"
 )
 
 var snapshotNameRegexp = regexp.MustCompile(`^[0-9]+\.json$`)
@@ -32,6 +34,9 @@ type Executor struct {
 	inputs           localGameInputs
 	cannon           string
 	server           string
+	network          string
+	rollupConfig     string
+	l2Genesis        string
 	absolutePreState string
 	dataDir          string
 	snapshotFreq     uint
@@ -47,6 +52,9 @@ func NewExecutor(logger log.Logger, cfg *config.Config, inputs localGameInputs)
 		inputs:           inputs,
 		cannon:           cfg.CannonBin,
 		server:           cfg.CannonServer,
+		network:          cfg.CannonNetwork,
+		rollupConfig:     cfg.CannonRollupConfigPath,
+		l2Genesis:        cfg.CannonL2GenesisPath,
 		absolutePreState: cfg.CannonAbsolutePreState,
 		dataDir:          cfg.CannonDatadir,
 		snapshotFreq:     cfg.CannonSnapshotFreq,
@@ -69,12 +77,11 @@ func (e *Executor) GenerateProof(ctx context.Context, dir string, i uint64) erro
 		"--output", filepath.Join(dir, "out.json"),
 		"--meta", "",
 		"--proof-at", "=" + strconv.FormatUint(i, 10),
-		"--stop-at", "=" + strconv.FormatUint(i+1, 10),
 		"--proof-fmt", filepath.Join(proofDir, "%d.json"),
 		"--snapshot-at", "%" + strconv.FormatUint(uint64(e.snapshotFreq), 10),
 		"--snapshot-fmt", filepath.Join(snapshotDir, "%d.json"),
 		"--",
-		e.server,
+		e.server, "--server",
 		"--l1", e.l1,
 		"--l2", e.l2,
 		"--datadir", dataDir,
@@ -84,6 +91,18 @@ func (e *Executor) GenerateProof(ctx context.Context, dir string, i uint64) erro
 		"--l2.claim", e.inputs.l2Claim.Hex(),
 		"--l2.blocknumber", e.inputs.l2BlockNumber.Text(10),
 	}
+	if i < math.MaxUint64 {
+		args = append(args, "--stop-at", "="+strconv.FormatUint(i+1, 10))
+	}
+	if e.network != "" {
+		args = append(args, "--network", e.network)
+	}
+	if e.rollupConfig != "" {
+		args = append(args, "--rollup.config", e.rollupConfig)
+	}
+	if e.l2Genesis != "" {
+		args = append(args, "--l2.genesis", e.l2Genesis)
+	}
 
 	if err := os.MkdirAll(snapshotDir, 0755); err != nil {
 		return fmt.Errorf("could not create snapshot directory %v: %w", snapshotDir, err)
@@ -94,7 +113,7 @@ func (e *Executor) GenerateProof(ctx context.Context, dir string, i uint64) erro
 	if err := os.MkdirAll(proofDir, 0755); err != nil {
 		return fmt.Errorf("could not create proofs directory %v: %w", proofDir, err)
 	}
-	e.logger.Info("Generating trace", "proof", i, "cmd", e.cannon, "args", args)
+	e.logger.Info("Generating trace", "proof", i, "cmd", e.cannon, "args", strings.Join(args, ", "))
 	return e.cmdExecutor(ctx, e.logger.New("proof", i), e.cannon, args...)
 }
 
@@ -102,7 +121,8 @@ func runCmd(ctx context.Context, l log.Logger, binary string, args ...string) er
 	cmd := exec.CommandContext(ctx, binary, args...)
 	stdOut := oplog.NewWriter(l, log.LvlInfo)
 	defer stdOut.Close()
-	stdErr := oplog.NewWriter(l, log.LvlError)
+	// Keep stdErr at info level because cannon uses stderr for progress messages
+	stdErr := oplog.NewWriter(l, log.LvlInfo)
 	defer stdErr.Close()
 	cmd.Stdout = stdOut
 	cmd.Stderr = stdErr
@@ -123,17 +143,17 @@ func findStartingSnapshot(logger log.Logger, snapDir string, absolutePreState st
 	bestSnap := uint64(0)
 	for _, entry := range entries {
 		if entry.IsDir() {
-			logger.Warn("Unexpected directory in snapshots dir: %v/%v", snapDir, entry.Name())
+			logger.Warn("Unexpected directory in snapshots dir", "parent", snapDir, "child", entry.Name())
 			continue
 		}
 		name := entry.Name()
 		if !snapshotNameRegexp.MatchString(name) {
-			logger.Warn("Unexpected file in snapshots dir: %v/%v", snapDir, entry.Name())
+			logger.Warn("Unexpected file in snapshots dir", "parent", snapDir, "child", entry.Name())
 			continue
 		}
 		index, err := strconv.ParseUint(name[0:len(name)-len(".json")], 10, 64)
 		if err != nil {
-			logger.Error("Unable to parse trace index of snapshot file: %v/%v", snapDir, entry.Name())
+			logger.Error("Unable to parse trace index of snapshot file", "parent", snapDir, "child", entry.Name())
 			continue
 		}
 		if index > bestSnap && index < traceIndex {

op-challenger/fault/cannon/executor_test.go

@@ -3,6 +3,7 @@ package cannon
 import (
 	"context"
 	"fmt"
+	"math"
 	"math/big"
 	"os"
 	"path/filepath"
@@ -35,49 +36,90 @@ func TestGenerateProof(t *testing.T) {
 		l2Claim:       common.Hash{0x44},
 		l2BlockNumber: big.NewInt(3333),
 	}
-
-	executor := NewExecutor(testlog.Logger(t, log.LvlInfo), &cfg, inputs)
-	executor.selectSnapshot = func(logger log.Logger, dir string, absolutePreState string, i uint64) (string, error) {
-		return input, nil
-	}
-	var binary string
-	var subcommand string
-	args := make(map[string]string)
-	executor.cmdExecutor = func(ctx context.Context, l log.Logger, b string, a ...string) error {
-		binary = b
-		subcommand = a[0]
-		for i := 1; i < len(a); i += 2 {
-			args[a[i]] = a[i+1]
+	captureExec := func(cfg config.Config, proofAt uint64) (string, string, map[string]string) {
+		executor := NewExecutor(testlog.Logger(t, log.LvlInfo), &cfg, inputs)
+		executor.selectSnapshot = func(logger log.Logger, dir string, absolutePreState string, i uint64) (string, error) {
+			return input, nil
+		}
+		var binary string
+		var subcommand string
+		args := make(map[string]string)
+		executor.cmdExecutor = func(ctx context.Context, l log.Logger, b string, a ...string) error {
+			binary = b
+			subcommand = a[0]
+			for i := 1; i < len(a); {
+				if a[i] == "--" {
+					// Skip over the divider between cannon and server program
+					i += 1
+					continue
+				}
+				args[a[i]] = a[i+1]
+				i += 2
+			}
+			return nil
 		}
-		return nil
+		err := executor.GenerateProof(context.Background(), cfg.CannonDatadir, proofAt)
+		require.NoError(t, err)
+		return binary, subcommand, args
 	}
-	err := executor.GenerateProof(context.Background(), cfg.CannonDatadir, 150_000_000)
-	require.NoError(t, err)
-	require.DirExists(t, filepath.Join(cfg.CannonDatadir, preimagesDir))
-	require.DirExists(t, filepath.Join(cfg.CannonDatadir, proofsDir))
-	require.DirExists(t, filepath.Join(cfg.CannonDatadir, snapsDir))
-	require.Equal(t, cfg.CannonBin, binary)
-	require.Equal(t, "run", subcommand)
-	require.Equal(t, input, args["--input"])
-	require.Contains(t, args, "--meta")
-	require.Equal(t, "", args["--meta"])
-	require.Equal(t, filepath.Join(cfg.CannonDatadir, "out.json"), args["--output"])
-	require.Equal(t, "=150000000", args["--proof-at"])
-	require.Equal(t, "=150000001", args["--stop-at"])
-	require.Equal(t, "%500", args["--snapshot-at"])
-	require.Equal(t, cfg.CannonServer, args["--"])
-	require.Equal(t, cfg.L1EthRpc, args["--l1"])
-	require.Equal(t, cfg.CannonL2, args["--l2"])
-	require.Equal(t, filepath.Join(cfg.CannonDatadir, preimagesDir), args["--datadir"])
-	require.Equal(t, filepath.Join(cfg.CannonDatadir, proofsDir, "%d.json"), args["--proof-fmt"])
-	require.Equal(t, filepath.Join(cfg.CannonDatadir, snapsDir, "%d.json"), args["--snapshot-fmt"])
-
-	// Local game inputs
-	require.Equal(t, inputs.l1Head.Hex(), args["--l1.head"])
-	require.Equal(t, inputs.l2Head.Hex(), args["--l2.head"])
-	require.Equal(t, inputs.l2OutputRoot.Hex(), args["--l2.outputroot"])
-	require.Equal(t, inputs.l2Claim.Hex(), args["--l2.claim"])
-	require.Equal(t, "3333", args["--l2.blocknumber"])
+
+	t.Run("Network", func(t *testing.T) {
+		cfg.CannonNetwork = "mainnet"
+		cfg.CannonRollupConfigPath = ""
+		cfg.CannonL2GenesisPath = ""
+		binary, subcommand, args := captureExec(cfg, 150_000_000)
+		require.DirExists(t, filepath.Join(cfg.CannonDatadir, preimagesDir))
+		require.DirExists(t, filepath.Join(cfg.CannonDatadir, proofsDir))
+		require.DirExists(t, filepath.Join(cfg.CannonDatadir, snapsDir))
+		require.Equal(t, cfg.CannonBin, binary)
+		require.Equal(t, "run", subcommand)
+		require.Equal(t, input, args["--input"])
+		require.Contains(t, args, "--meta")
+		require.Equal(t, "", args["--meta"])
+		require.Equal(t, filepath.Join(cfg.CannonDatadir, "out.json"), args["--output"])
+		require.Equal(t, "=150000000", args["--proof-at"])
+		require.Equal(t, "=150000001", args["--stop-at"])
+		require.Equal(t, "%500", args["--snapshot-at"])
+		// Slight quirk of how we pair off args
+		// The server binary winds up as the key and the first arg --server as the value which has no value
+		// Then everything else pairs off correctly again
+		require.Equal(t, "--server", args[cfg.CannonServer])
+		require.Equal(t, cfg.L1EthRpc, args["--l1"])
+		require.Equal(t, cfg.CannonL2, args["--l2"])
+		require.Equal(t, filepath.Join(cfg.CannonDatadir, preimagesDir), args["--datadir"])
+		require.Equal(t, filepath.Join(cfg.CannonDatadir, proofsDir, "%d.json"), args["--proof-fmt"])
+		require.Equal(t, filepath.Join(cfg.CannonDatadir, snapsDir, "%d.json"), args["--snapshot-fmt"])
+		require.Equal(t, cfg.CannonNetwork, args["--network"])
+		require.NotContains(t, args, "--rollup.config")
+		require.NotContains(t, args, "--l2.genesis")
+
+		// Local game inputs
+		require.Equal(t, inputs.l1Head.Hex(), args["--l1.head"])
+		require.Equal(t, inputs.l2Head.Hex(), args["--l2.head"])
+		require.Equal(t, inputs.l2OutputRoot.Hex(), args["--l2.outputroot"])
+		require.Equal(t, inputs.l2Claim.Hex(), args["--l2.claim"])
+		require.Equal(t, "3333", args["--l2.blocknumber"])
+	})
+
+	t.Run("RollupAndGenesis", func(t *testing.T) {
+		cfg.CannonNetwork = ""
+		cfg.CannonRollupConfigPath = "rollup.json"
+		cfg.CannonL2GenesisPath = "genesis.json"
+		_, _, args := captureExec(cfg, 150_000_000)
+		require.NotContains(t, args, "--network")
+		require.Equal(t, cfg.CannonRollupConfigPath, args["--rollup.config"])
+		require.Equal(t, cfg.CannonL2GenesisPath, args["--l2.genesis"])
+	})
+
+	t.Run("NoStopAtWhenProofIsMaxUInt", func(t *testing.T) {
+		cfg.CannonNetwork = "mainnet"
+		cfg.CannonRollupConfigPath = "rollup.json"
+		cfg.CannonL2GenesisPath = "genesis.json"
+		_, _, args := captureExec(cfg, math.MaxUint64)
+		// stop-at would need to be one more than the proof step which would overflow back to 0
+		// so expect that it will be omitted. We'll ultimately want cannon to execute until the program exits.
+		require.NotContains(t, args, "--stop-at")
+	})
 }
 
 func TestRunCmdLogsOutput(t *testing.T) {

op-challenger/flags/flags.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 
 	"github.com/ethereum-optimism/optimism/op-challenger/config"
+	"github.com/ethereum-optimism/optimism/op-node/chaincfg"
 	opservice "github.com/ethereum-optimism/optimism/op-service"
 	openum "github.com/ethereum-optimism/optimism/op-service/enum"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
@@ -58,6 +59,21 @@ var (
 		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(), ", ")),
+		EnvVars: prefixEnvVars("CANNON_NETWORK"),
+	}
+	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)",
@@ -103,6 +119,9 @@ var requiredFlags = []cli.Flag{
 // optionalFlags is a list of unchecked cli flags
 var optionalFlags = []cli.Flag{
 	AlphabetFlag,
+	CannonNetworkFlag,
+	CannonRollupConfigFlag,
+	CannonL2GenesisFlag,
 	CannonBinFlag,
 	CannonServerFlag,
 	CannonPreStateFlag,
@@ -130,6 +149,14 @@ func CheckRequired(ctx *cli.Context) error {
 	gameType := config.TraceType(strings.ToLower(ctx.String(TraceTypeFlag.Name)))
 	switch gameType {
 	case config.TraceTypeCannon:
+		if !ctx.IsSet(CannonNetworkFlag.Name) && !(ctx.IsSet(CannonRollupConfigFlag.Name) && ctx.IsSet(CannonL2GenesisFlag.Name)) {
+			return fmt.Errorf("flag %v or %v and %v is required",
+				CannonNetworkFlag.Name, CannonRollupConfigFlag.Name, CannonL2GenesisFlag.Name)
+		}
+		if ctx.IsSet(CannonNetworkFlag.Name) && (ctx.IsSet(CannonRollupConfigFlag.Name) || ctx.IsSet(CannonL2GenesisFlag.Name)) {
+			return fmt.Errorf("flag %v can not be used with %v and %v",
+				CannonNetworkFlag.Name, CannonRollupConfigFlag.Name, CannonL2GenesisFlag.Name)
+		}
 		if !ctx.IsSet(CannonBinFlag.Name) {
 			return fmt.Errorf("flag %s is required", CannonBinFlag.Name)
 		}
@@ -175,6 +202,9 @@ func NewConfigFromCLI(ctx *cli.Context) (*config.Config, error) {
 		TraceType:               traceTypeFlag,
 		GameAddress:             dgfAddress,
 		AlphabetTrace:           ctx.String(AlphabetFlag.Name),
+		CannonNetwork:           ctx.String(CannonNetworkFlag.Name),
+		CannonRollupConfigPath:  ctx.String(CannonRollupConfigFlag.Name),
+		CannonL2GenesisPath:     ctx.String(CannonL2GenesisFlag.Name),
 		CannonBin:               ctx.String(CannonBinFlag.Name),
 		CannonServer:            ctx.String(CannonServerFlag.Name),
 		CannonAbsolutePreState:  ctx.String(CannonPreStateFlag.Name),

op-e2e/e2eutils/disputegame/cannon_helper.go

@@ -2,16 +2,21 @@ package disputegame
 
 import (
 	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
 
 	"github.com/ethereum-optimism/optimism/op-challenger/config"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/challenger"
+	"github.com/ethereum-optimism/optimism/op-node/rollup"
+	"github.com/ethereum/go-ethereum/core"
 )
 
 type CannonGameHelper struct {
 	FaultGameHelper
 }
 
-func (g *CannonGameHelper) StartChallenger(ctx context.Context, l1Endpoint string, l2Endpoint string, name string, options ...challenger.Option) *challenger.Helper {
+func (g *CannonGameHelper) StartChallenger(ctx context.Context, rollupCfg *rollup.Config, l2Genesis *core.Genesis, l1Endpoint string, l2Endpoint string, name string, options ...challenger.Option) *challenger.Helper {
 	opts := []challenger.Option{
 		func(c *config.Config) {
 			c.GameAddress = g.addr
@@ -24,6 +29,18 @@ func (g *CannonGameHelper) StartChallenger(ctx context.Context, l1Endpoint strin
 			c.CannonServer = "../op-program/bin/op-program"
 			c.CannonAbsolutePreState = "../op-program/bin/prestate.json"
 			c.CannonSnapshotFreq = config.DefaultCannonSnapshotFreq
+
+			genesisBytes, err := json.Marshal(l2Genesis)
+			g.require.NoError(err, "marshall l2 genesis config")
+			genesisFile := filepath.Join(c.CannonDatadir, "l2-genesis.json")
+			g.require.NoError(os.WriteFile(genesisFile, genesisBytes, 0644))
+			c.CannonL2GenesisPath = genesisFile
+
+			rollupBytes, err := json.Marshal(rollupCfg)
+			g.require.NoError(err, "marshall rollup config")
+			rollupFile := filepath.Join(c.CannonDatadir, "rollup.json")
+			g.require.NoError(os.WriteFile(rollupFile, rollupBytes, 0644))
+			c.CannonRollupConfigPath = rollupFile
 		},
 	}
 	opts = append(opts, options...)

op-e2e/faultproof_test.go

@@ -156,7 +156,7 @@ func TestCannonDisputeGame(t *testing.T) {
 	game := disputeGameFactory.StartCannonGame(ctx, common.Hash{0xaa})
 	require.NotNil(t, game)
 
-	game.StartChallenger(ctx, sys.NodeEndpoint("l1"), sys.NodeEndpoint("sequencer"), "Challenger", func(c *config.Config) {
+	game.StartChallenger(ctx, sys.RollupConfig, sys.L2GenesisCfg, sys.NodeEndpoint("l1"), sys.NodeEndpoint("sequencer"), "Challenger", func(c *config.Config) {
 		c.AgreeWithProposedOutput = true // Agree with the proposed output, so disagree with the root claim
 		c.TxMgrConfig.PrivateKey = e2eutils.EncodePrivKeyToString(sys.cfg.Secrets.Alice)
 	})
@@ -173,8 +173,10 @@ func TestCannonDisputeGame(t *testing.T) {
 func startFaultDisputeSystem(t *testing.T) (*System, *ethclient.Client) {
 	cfg := DefaultSystemConfig(t)
 	delete(cfg.Nodes, "verifier")
+	cfg.DeployConfig.SequencerWindowSize = 4
+	cfg.DeployConfig.FinalizationPeriodSeconds = 2
 	cfg.SupportL1TimeTravel = true
-	cfg.DeployConfig.L2OutputOracleSubmissionInterval = 2
+	cfg.DeployConfig.L2OutputOracleSubmissionInterval = 1
 	cfg.NonFinalizedProposals = true // Submit output proposals asap
 	sys, err := cfg.Start()
 	require.NoError(t, err, "Error starting up system")