Merge pull request #6622 from ethereum-optimism/aj/cannon-executor-fixes

op-challenger: Fix cannon execution

op-challenger/fault/cannon/executor.go

@@ -56,31 +56,44 @@ func NewExecutor(logger log.Logger, cfg *config.Config, inputs localGameInputs)
 }
 
 func (e *Executor) GenerateProof(ctx context.Context, dir string, i uint64) error {
-	start, err := e.selectSnapshot(e.logger, filepath.Join(e.dataDir, snapsDir), e.absolutePreState, i)
+	snapshotDir := filepath.Join(dir, snapsDir)
+	start, err := e.selectSnapshot(e.logger, snapshotDir, e.absolutePreState, i)
 	if err != nil {
 		return fmt.Errorf("find starting snapshot: %w", err)
 	}
+	proofDir := filepath.Join(dir, proofsDir)
+	dataDir := filepath.Join(e.dataDir, preimagesDir)
 	args := []string{
 		"run",
 		"--input", start,
+		"--output", filepath.Join(dir, "out.json"),
+		"--meta", "",
 		"--proof-at", "=" + strconv.FormatUint(i, 10),
 		"--stop-at", "=" + strconv.FormatUint(i+1, 10),
-		"--proof-fmt", filepath.Join(dir, proofsDir, "%d.json"),
+		"--proof-fmt", filepath.Join(proofDir, "%d.json"),
 		"--snapshot-at", "%" + strconv.FormatUint(uint64(e.snapshotFreq), 10),
-		"--snapshot-fmt", filepath.Join(e.dataDir, snapsDir, "%d.json"),
+		"--snapshot-fmt", filepath.Join(snapshotDir, "%d.json"),
 		"--",
 		e.server,
 		"--l1", e.l1,
 		"--l2", e.l2,
-		"--datadir", filepath.Join(e.dataDir, preimagesDir),
+		"--datadir", dataDir,
 		"--l1.head", e.inputs.l1Head.Hex(),
 		"--l2.head", e.inputs.l2Head.Hex(),
 		"--l2.outputroot", e.inputs.l2OutputRoot.Hex(),
 		"--l2.claim", e.inputs.l2Claim.Hex(),
 		"--l2.blocknumber", e.inputs.l2BlockNumber.Text(10),
-		"--l2.chainid", e.inputs.l2ChainId.Text(10),
 	}
 
+	if err := os.MkdirAll(snapshotDir, 0755); err != nil {
+		return fmt.Errorf("could not create snapshot directory %v: %w", snapshotDir, err)
+	}
+	if err := os.MkdirAll(dataDir, 0755); err != nil {
+		return fmt.Errorf("could not create preimage cache directory %v: %w", dataDir, err)
+	}
+	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)
 	return e.cmdExecutor(ctx, e.logger.New("proof", i), e.cannon, args...)
 }

op-challenger/fault/cannon/executor_test.go

@@ -30,7 +30,6 @@ func TestGenerateProof(t *testing.T) {
 
 	inputs := localGameInputs{
 		l1Head:        common.Hash{0x11},
-		l2ChainId:     big.NewInt(2342),
 		l2Head:        common.Hash{0x22},
 		l2OutputRoot:  common.Hash{0x33},
 		l2Claim:       common.Hash{0x44},
@@ -54,9 +53,15 @@ func TestGenerateProof(t *testing.T) {
 	}
 	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"])
@@ -73,7 +78,6 @@ func TestGenerateProof(t *testing.T) {
 	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"])
-	require.Equal(t, "2342", args["--l2.chainid"])
 }
 
 func TestRunCmdLogsOutput(t *testing.T) {

op-challenger/fault/cannon/local.go

@@ -13,7 +13,6 @@ import (
 
 type localGameInputs struct {
 	l1Head        common.Hash
-	l2ChainId     *big.Int
 	l2Head        common.Hash
 	l2OutputRoot  common.Hash
 	l2Claim       common.Hash
@@ -39,10 +38,6 @@ func fetchLocalInputs(ctx context.Context, gameAddr common.Address, caller GameI
 	if err != nil {
 		return localGameInputs{}, fmt.Errorf("fetch L1 head for game %v: %w", gameAddr, err)
 	}
-	l2ChainId, err := l2Client.ChainID(ctx)
-	if err != nil {
-		return localGameInputs{}, fmt.Errorf("fetch L2 chain ID: %w", err)
-	}
 
 	proposals, err := caller.Proposals(opts)
 	if err != nil {
@@ -58,7 +53,6 @@ func fetchLocalInputs(ctx context.Context, gameAddr common.Address, caller GameI
 
 	return localGameInputs{
 		l1Head:        l1Head,
-		l2ChainId:     l2ChainId,
 		l2Head:        l2Head,
 		l2OutputRoot:  agreedOutput.OutputRoot,
 		l2Claim:       claimedOutput.OutputRoot,

op-challenger/fault/cannon/local_test.go

@@ -40,7 +40,6 @@ func TestFetchLocalInputs(t *testing.T) {
 	require.NoError(t, err)
 
 	require.Equal(t, l1Client.l1Head, inputs.l1Head)
-	require.Equal(t, l2Client.chainID, inputs.l2ChainId)
 	require.Equal(t, l2Client.header.Hash(), inputs.l2Head)
 	require.EqualValues(t, l1Client.starting.OutputRoot, inputs.l2OutputRoot)
 	require.EqualValues(t, l1Client.disputed.OutputRoot, inputs.l2Claim)