Merge branch 'develop' into simplify/unreachable

op-challenger/config/config.go

@@ -35,27 +35,19 @@ const (
 	TraceTypeAlphabet TraceType = "alphabet"
 	TraceTypeCannon   TraceType = "cannon"
 
-	// Devnet game IDs
-	DevnetGameIDAlphabet = uint8(0)
-	DevnetGameIDCannon   = uint8(1)
+	// Mainnet games
+	CannonFaultGameID = 0
 
-	// Mainnet game IDs
-	MainnetGameIDFault = uint8(0)
+	// Devnet games
+	AlphabetFaultGameID = 255
 )
 
 var TraceTypes = []TraceType{TraceTypeAlphabet, TraceTypeCannon}
 
-// GameIdToString maps game IDs to their string representation on a per-network basis.
-var GameIdToString = map[uint64]map[uint8]string{
-	// Mainnet
-	1: {
-		MainnetGameIDFault: "fault-cannon",
-	},
-	// Devnet
-	900: {
-		DevnetGameIDAlphabet: "fault-alphabet",
-		DevnetGameIDCannon:   "fault-cannon",
-	},
+// GameIdToString maps game IDs to their string representation.
+var GameIdToString = map[uint8]string{
+	CannonFaultGameID:   "Cannon",
+	AlphabetFaultGameID: "Alphabet",
 }
 
 func (t TraceType) String() string {

op-challenger/fault/cannon/executor.go

@@ -39,7 +39,6 @@ type Executor struct {
 	rollupConfig     string
 	l2Genesis        string
 	absolutePreState string
-	dataDir          string
 	snapshotFreq     uint
 	selectSnapshot   snapshotSelect
 	cmdExecutor      cmdExecutor
@@ -57,7 +56,6 @@ func NewExecutor(logger log.Logger, cfg *config.Config, inputs LocalGameInputs)
 		rollupConfig:     cfg.CannonRollupConfigPath,
 		l2Genesis:        cfg.CannonL2GenesisPath,
 		absolutePreState: cfg.CannonAbsolutePreState,
-		dataDir:          cfg.CannonDatadir,
 		snapshotFreq:     cfg.CannonSnapshotFreq,
 		selectSnapshot:   findStartingSnapshot,
 		cmdExecutor:      runCmd,
@@ -71,7 +69,7 @@ func (e *Executor) GenerateProof(ctx context.Context, dir string, i uint64) erro
 		return fmt.Errorf("find starting snapshot: %w", err)
 	}
 	proofDir := filepath.Join(dir, proofsDir)
-	dataDir := filepath.Join(e.dataDir, preimagesDir)
+	dataDir := filepath.Join(dir, preimagesDir)
 	lastGeneratedState := filepath.Join(dir, finalState)
 	args := []string{
 		"run",

op-challenger/fault/cannon/executor_test.go

@@ -22,7 +22,9 @@ const execTestCannonPrestate = "/foo/pre.json"
 func TestGenerateProof(t *testing.T) {
 	input := "starting.json"
 	cfg := config.NewConfig(common.Address{0xbb}, "http://localhost:8888", config.TraceTypeCannon, true)
-	cfg.CannonDatadir = t.TempDir()
+	tempDir := t.TempDir()
+	dir := filepath.Join(tempDir, "gameDir")
+	cfg.CannonDatadir = tempDir
 	cfg.CannonAbsolutePreState = "pre.json"
 	cfg.CannonBin = "./bin/cannon"
 	cfg.CannonServer = "./bin/op-program"
@@ -58,7 +60,7 @@ func TestGenerateProof(t *testing.T) {
 			}
 			return nil
 		}
-		err := executor.GenerateProof(context.Background(), cfg.CannonDatadir, proofAt)
+		err := executor.GenerateProof(context.Background(), dir, proofAt)
 		require.NoError(t, err)
 		return binary, subcommand, args
 	}
@@ -68,15 +70,15 @@ func TestGenerateProof(t *testing.T) {
 		cfg.CannonRollupConfigPath = ""
 		cfg.CannonL2GenesisPath = ""
 		binary, subcommand, args := captureExec(t, 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.DirExists(t, filepath.Join(dir, preimagesDir))
+		require.DirExists(t, filepath.Join(dir, proofsDir))
+		require.DirExists(t, filepath.Join(dir, 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, finalState), args["--output"])
+		require.Equal(t, filepath.Join(dir, finalState), args["--output"])
 		require.Equal(t, "=150000000", args["--proof-at"])
 		require.Equal(t, "=150000001", args["--stop-at"])
 		require.Equal(t, "%500", args["--snapshot-at"])
@@ -86,9 +88,9 @@ func TestGenerateProof(t *testing.T) {
 		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, filepath.Join(dir, preimagesDir), args["--datadir"])
+		require.Equal(t, filepath.Join(dir, proofsDir, "%d.json"), args["--proof-fmt"])
+		require.Equal(t, filepath.Join(dir, 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")

op-challenger/fault/cannon/provider.go

@@ -64,13 +64,14 @@ func NewTraceProvider(ctx context.Context, logger log.Logger, cfg *config.Config
 	if err != nil {
 		return nil, fmt.Errorf("fetch local game inputs: %w", err)
 	}
-	return NewTraceProviderFromInputs(logger, cfg, localInputs), nil
+	return NewTraceProviderFromInputs(logger, cfg, gameAddr.Hex(), localInputs), nil
 }
 
-func NewTraceProviderFromInputs(logger log.Logger, cfg *config.Config, localInputs LocalGameInputs) *CannonTraceProvider {
+func NewTraceProviderFromInputs(logger log.Logger, cfg *config.Config, gameDirName string, localInputs LocalGameInputs) *CannonTraceProvider {
+	dir := filepath.Join(cfg.CannonDatadir, gameDirName)
 	return &CannonTraceProvider{
 		logger:    logger,
-		dir:       cfg.CannonDatadir,
+		dir:       dir,
 		prestate:  cfg.CannonAbsolutePreState,
 		generator: NewExecutor(logger, cfg, localInputs),
 	}

op-challenger/fault/cannon/provider_test.go

@@ -11,6 +11,7 @@ import (
 	"testing"
 
 	"github.com/ethereum-optimism/optimism/cannon/mipsevm"
+	"github.com/ethereum-optimism/optimism/op-challenger/config"
 	"github.com/ethereum-optimism/optimism/op-challenger/fault/types"
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
 	"github.com/ethereum/go-ethereum/common"
@@ -149,7 +150,6 @@ func TestGetStepData(t *testing.T) {
 
 func TestAbsolutePreState(t *testing.T) {
 	dataDir := t.TempDir()
-	_ = os.Mkdir(dataDir, 0o777)
 
 	prestate := "state.json"
 
@@ -189,6 +189,21 @@ func TestAbsolutePreState(t *testing.T) {
 	})
 }
 
+func TestUseGameSpecificSubdir(t *testing.T) {
+	tempDir := t.TempDir()
+	dataDir := filepath.Join(tempDir, "data")
+	setupPreState(t, tempDir, "state.json")
+	logger := testlog.Logger(t, log.LvlInfo)
+	cfg := &config.Config{
+		CannonAbsolutePreState: filepath.Join(tempDir, "state.json"),
+		CannonDatadir:          dataDir,
+	}
+	gameDirName := "gameSubdir"
+	localInputs := LocalGameInputs{}
+	provider := NewTraceProviderFromInputs(logger, cfg, gameDirName, localInputs)
+	require.Equal(t, filepath.Join(dataDir, gameDirName), provider.dir, "should use game specific subdir")
+}
+
 func setupPreState(t *testing.T, dataDir string, filename string) {
 	srcDir := filepath.Join("test_data")
 	path := filepath.Join(srcDir, filename)

op-challenger/scripts/alphabet/init_game.sh

@@ -78,8 +78,8 @@ cast call $L2_OUTPUT_ORACLE_PROXY "getL2Output(uint256)" $PRIOR_INDEX
 echo "Getting the l2 output at index $INDEX"
 cast call $L2_OUTPUT_ORACLE_PROXY "getL2Output(uint256)" $INDEX
 
-# (Alphabet) Fault game type = 0
-GAME_TYPE=0
+# (Alphabet) Fault game type = 255
+GAME_TYPE=255
 
 # Root claim commits to the entire trace.
 # Alphabet game claim construction: keccak256(abi.encode(trace_index, trace[trace_index]))

op-e2e/e2eutils/disputegame/helper.go

@@ -26,8 +26,8 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-const alphabetGameType uint8 = 0
-const cannonGameType uint8 = 1
+const alphabetGameType uint8 = 255
+const cannonGameType uint8 = 0
 const alphabetGameDepth = 4
 const lastAlphabetTraceIndex = 1<<alphabetGameDepth - 1
 
@@ -170,7 +170,7 @@ func (h *FactoryHelper) StartCannonGameWithCorrectRoot(ctx context.Context, roll
 		L2Claim:       challengedOutput.OutputRoot,
 		L2BlockNumber: challengedOutput.L2BlockNumber,
 	}
-	provider := cannon.NewTraceProviderFromInputs(testlog.Logger(h.t, log.LvlInfo).New("role", "CorrectTrace"), cfg, inputs)
+	provider := cannon.NewTraceProviderFromInputs(testlog.Logger(h.t, log.LvlInfo).New("role", "CorrectTrace"), cfg, "correct", inputs)
 	rootClaim, err := provider.Get(ctx, math.MaxUint64)
 	h.require.NoError(err, "Compute correct root hash")
 

op-e2e/e2eutils/wait/waits.go

@@ -56,7 +56,8 @@ func (s *jsonRawString) UnmarshalJSON(input []byte) error {
 // printDebugTrace logs debug_traceTransaction output to aid in debugging unexpected receipt statuses
 func printDebugTrace(ctx context.Context, client *ethclient.Client, txHash common.Hash) {
 	var trace jsonRawString
-	options := map[string]string{}
+	options := map[string]any{}
+	options["enableReturnData"] = true
 	err := client.Client().CallContext(ctx, &trace, "debug_traceTransaction", hexutil.Bytes(txHash.Bytes()), options)
 	if err != nil {
 		fmt.Printf("TxTrace unavailable: %v\n", err)

op-e2e/faultproof_test.go

@@ -50,7 +50,6 @@ func TestMultipleAlphabetGames(t *testing.T) {
 }
 
 func TestMultipleCannonGames(t *testing.T) {
-	t.Skip("Cannon provider doesn't currently isolate different game traces")
 	InitParallel(t)
 
 	ctx := context.Background()

packages/contracts-bedrock/scripts/Deploy.s.sol

@@ -76,7 +76,8 @@ contract Deploy is Deployer {
         initializeL2OutputOracle();
         initializeOptimismPortal();
 
-        setFaultGameImplementation();
+        setAlphabetFaultGameImplementation();
+        setCannonFaultGameImplementation();
 
         transferProxyAdminOwnership();
         transferDisputeGameFactoryOwnership();
@@ -759,10 +760,13 @@ contract Deploy is Deployer {
     }
 
     /// @notice Sets the implementation for the `FAULT` game type in the `DisputeGameFactory`
-    function setFaultGameImplementation() public onlyDevnet broadcast {
-        // Create the absolute prestate dump
+    function setCannonFaultGameImplementation() public onlyDevnet broadcast {
+        DisputeGameFactory factory = DisputeGameFactory(mustGetAddress("DisputeGameFactoryProxy"));
+
+        Claim mipsAbsolutePrestate;
+        if (block.chainid == Chains.LocalDevnet || block.chainid == Chains.GethDevnet) {
+            // Fetch the absolute prestate dump
             string memory filePath = string.concat(vm.projectRoot(), "/../../op-program/bin/prestate-proof.json");
-        bytes32 mipsAbsolutePrestate;
             string[] memory commands = new string[](3);
             commands[0] = "bash";
             commands[1] = "-c";
@@ -771,35 +775,74 @@ contract Deploy is Deployer {
                 revert("Cannon prestate dump not found, generate it with `make cannon-prestate` in the monorepo root.");
             }
             commands[2] = string.concat("cat ", filePath, " | jq -r .pre");
-        mipsAbsolutePrestate = abi.decode(vm.ffi(commands), (bytes32));
-        console.log("Absolute prestate: %s", vm.toString(mipsAbsolutePrestate));
+            mipsAbsolutePrestate = Claim.wrap(abi.decode(vm.ffi(commands), (bytes32)));
+            console.log(
+                "[Cannon Dispute Game] Using devnet MIPS Absolute prestate: %s",
+                vm.toString(Claim.unwrap(mipsAbsolutePrestate))
+            );
+        } else {
+            console.log(
+                "[Cannon Dispute Game] Using absolute prestate from config: %s", cfg.faultGameAbsolutePrestate()
+            );
+            mipsAbsolutePrestate = Claim.wrap(bytes32(cfg.faultGameAbsolutePrestate()));
+        }
+
+        // Set the Cannon FaultDisputeGame implementation in the factory.
+        _setFaultGameImplementation(
+            factory, GameTypes.FAULT, mipsAbsolutePrestate, IBigStepper(mustGetAddress("Mips")), cfg.faultGameMaxDepth()
+        );
+    }
 
+    /// @notice Sets the implementation for the alphabet game type in the `DisputeGameFactory`
+    function setAlphabetFaultGameImplementation() public onlyDevnet broadcast {
         DisputeGameFactory factory = DisputeGameFactory(mustGetAddress("DisputeGameFactoryProxy"));
-        for (uint8 i; i < 2; i++) {
-            Claim absolutePrestate =
-                Claim.wrap(i == 0 ? bytes32(cfg.faultGameAbsolutePrestate()) : mipsAbsolutePrestate);
-            IBigStepper faultVm =
-                IBigStepper(i == 0 ? address(new AlphabetVM(absolutePrestate)) : mustGetAddress("Mips"));
-            GameType gameType = GameType.wrap(i);
-            if (address(factory.gameImpls(gameType)) == address(0)) {
-                factory.setImplementation(
-                    gameType,
+
+        // Set the Alphabet FaultDisputeGame implementation in the factory.
+        Claim alphabetAbsolutePrestate = Claim.wrap(bytes32(cfg.faultGameAbsolutePrestate()));
+        _setFaultGameImplementation(
+            factory,
+            GameType.wrap(255),
+            alphabetAbsolutePrestate,
+            IBigStepper(new AlphabetVM(alphabetAbsolutePrestate)),
+            4 // The max game depth of the alphabet game is always 4.
+        );
+    }
+
+    /// @notice Sets the implementation for the given fault game type in the `DisputeGameFactory`.
+    function _setFaultGameImplementation(
+        DisputeGameFactory _factory,
+        GameType _gameType,
+        Claim _absolutePrestate,
+        IBigStepper _faultVm,
+        uint256 _maxGameDepth
+    )
+        internal
+    {
+        if (address(_factory.gameImpls(_gameType)) == address(0)) {
+            _factory.setImplementation(
+                _gameType,
                 new FaultDisputeGame({
-                    _gameType: gameType,
-                    _absolutePrestate: absolutePrestate,
-                    _maxGameDepth: i == 0 ? 4 : cfg.faultGameMaxDepth(), // The max depth of the alphabet game is always 4
+                    _gameType: _gameType,
+                    _absolutePrestate: _absolutePrestate,
+                    _maxGameDepth: _maxGameDepth,
                     _gameDuration: Duration.wrap(uint64(cfg.faultGameMaxDuration())),
-                    _vm: faultVm,
+                    _vm: _faultVm,
                     _l2oo: L2OutputOracle(mustGetAddress("L2OutputOracleProxy")),
                     _blockOracle: BlockOracle(mustGetAddress("BlockOracle"))
                 })
             );
+
+            uint8 rawGameType = GameType.unwrap(_gameType);
             console.log(
                 "DisputeGameFactoryProxy: set `FaultDisputeGame` implementation (Backend: %s | GameType: %s)",
-                    i == 0 ? "AlphabetVM" : "MIPS",
-                    vm.toString(i)
+                rawGameType == 0 ? "Cannon" : "Alphabet",
+                vm.toString(rawGameType)
+            );
+        } else {
+            console.log(
+                "[WARN] DisputeGameFactoryProxy: `FaultDisputeGame` implementation already set for game type: %s",
+                vm.toString(GameType.unwrap(_gameType))
             );
-            }
         }
     }
 }