feat: opcm zk roots

op-chain-ops/interopgen/deployments.go

@@ -39,6 +39,7 @@ type Implementations struct {
 	PermissionedDisputeGameImpl      common.Address `json:"PermissionedDisputeGameImpl"`
 	SuperFaultDisputeGameImpl        common.Address `json:"SuperFaultDisputeGameImpl"`
 	SuperPermissionedDisputeGameImpl common.Address `json:"SuperPermissionedDisputeGameImpl"`
+	ZkDisputeGameImpl                common.Address `json:"ZkDisputeGameImpl"`
 	StorageSetterImpl                common.Address `json:"StorageSetterImpl"`
 }
 

op-deployer/pkg/deployer/integration_test/apply_test.go

@@ -1012,6 +1012,11 @@ func runEndToEndBootstrapAndApplyUpgradeTest(t *testing.T, afactsFS foundry.Stat
 								InitBond: big.NewInt(0),
 								GameType: embedded.GameTypeSuperCannonKona,
 							},
+							{
+								Enabled:  false,
+								InitBond: big.NewInt(0),
+								GameType: embedded.GameTypeZKDisputeGame,
+							},
 						},
 						ExtraInstructions: []embedded.ExtraInstruction{
 							{
@@ -1034,27 +1039,29 @@ func runEndToEndBootstrapAndApplyUpgradeTest(t *testing.T, afactsFS foundry.Stat
 				// Structure breakdown:
 				// - Tuple offset (0x20)
 				// - SystemConfig address (0x034edd2a225f7f429a63e0f1d2084b9e0a93b538)
-				// - DisputeGameConfigs array offset (0x60) and ExtraInstructions array offset (0x580)
-				// - DisputeGameConfigs[]: 6 configs
+				// - DisputeGameConfigs array offset (0x60) and ExtraInstructions array offset (0x640)
+				// - DisputeGameConfigs[]: 7 configs
 				//   [0] Cannon: enabled=true, initBond=1e18, gameType=0, gameArgs="PRESTATE"
 				//   [1] PermissionedCannon: enabled=true, initBond=1e18, gameType=1, gameArgs="PRESTATE"+proposer+challenger
 				//   [2] CannonKona: enabled=false, initBond=0, gameType=8, gameArgs=empty
 				//   [3] SuperCannon: enabled=false, initBond=0, gameType=4, gameArgs=empty
 				//   [4] SuperPermCannon: enabled=false, initBond=0, gameType=5, gameArgs=empty
 				//   [5] SuperCannonKona: enabled=false, initBond=0, gameType=9, gameArgs=empty
+				//   [6] ZKDisputeGame: enabled=false, initBond=0, gameType=10, gameArgs=empty
 				// - ExtraInstructions[]: 1 instruction
 				//   [0] key="PermittedProxyDeployment", data="DelayedWETH"
 				expected := "0000000000000000000000000000000000000000000000000000000000000020" + // offset to tuple
 					"000000000000000000000000034edd2a225f7f429a63e0f1d2084b9e0a93b538" + // systemConfig address
 					"0000000000000000000000000000000000000000000000000000000000000060" + // offset to disputeGameConfigs
-					"0000000000000000000000000000000000000000000000000000000000000580" + // offset to extraInstructions
-					"0000000000000000000000000000000000000000000000000000000000000006" + // disputeGameConfigs.length (6)
-					"00000000000000000000000000000000000000000000000000000000000000c0" + // offset to disputeGameConfigs[0]
-					"0000000000000000000000000000000000000000000000000000000000000180" + // offset to disputeGameConfigs[1]
-					"0000000000000000000000000000000000000000000000000000000000000280" + // offset to disputeGameConfigs[2]
-					"0000000000000000000000000000000000000000000000000000000000000320" + // offset to disputeGameConfigs[3]
-					"00000000000000000000000000000000000000000000000000000000000003c0" + // offset to disputeGameConfigs[4]
-					"0000000000000000000000000000000000000000000000000000000000000460" + // offset to disputeGameConfigs[5]
+					"0000000000000000000000000000000000000000000000000000000000000640" + // offset to extraInstructions
+					"0000000000000000000000000000000000000000000000000000000000000007" + // disputeGameConfigs.length (7)
+					"00000000000000000000000000000000000000000000000000000000000000e0" + // offset to disputeGameConfigs[0]
+					"00000000000000000000000000000000000000000000000000000000000001a0" + // offset to disputeGameConfigs[1]
+					"00000000000000000000000000000000000000000000000000000000000002a0" + // offset to disputeGameConfigs[2]
+					"0000000000000000000000000000000000000000000000000000000000000340" + // offset to disputeGameConfigs[3]
+					"00000000000000000000000000000000000000000000000000000000000003e0" + // offset to disputeGameConfigs[4]
+					"0000000000000000000000000000000000000000000000000000000000000480" + // offset to disputeGameConfigs[5]
+					"0000000000000000000000000000000000000000000000000000000000000520" + // offset to disputeGameConfigs[6]
 					// DisputeGameConfigs[0] - Cannon
 					"0000000000000000000000000000000000000000000000000000000000000001" + // enabled=true
 					"0000000000000000000000000000000000000000000000000de0b6b3a7640000" + // initBond=1e18
@@ -1095,6 +1102,12 @@ func runEndToEndBootstrapAndApplyUpgradeTest(t *testing.T, afactsFS foundry.Stat
 					"0000000000000000000000000000000000000000000000000000000000000009" + // gameType=9 (SuperCannonKona)
 					"0000000000000000000000000000000000000000000000000000000000000080" + // offset to gameArgs
 					"0000000000000000000000000000000000000000000000000000000000000000" + // gameArgs.length (0)
+					// DisputeGameConfigs[6] - ZKDisputeGame (disabled)
+					"0000000000000000000000000000000000000000000000000000000000000000" + // enabled=false
+					"0000000000000000000000000000000000000000000000000000000000000000" + // initBond=0
+					"000000000000000000000000000000000000000000000000000000000000000a" + // gameType=10 (ZKDisputeGame)
+					"0000000000000000000000000000000000000000000000000000000000000080" + // offset to gameArgs
+					"0000000000000000000000000000000000000000000000000000000000000000" + // gameArgs.length (0)
 					// ExtraInstructions array
 					"0000000000000000000000000000000000000000000000000000000000000001" + // extraInstructions.length (1)
 					"0000000000000000000000000000000000000000000000000000000000000020" + // offset to extraInstructions[0]

op-deployer/pkg/deployer/integration_test/cli/manage_add_game_type_v2_test.go

@@ -179,6 +179,11 @@ func TestManageAddGameTypeV2_Integration(t *testing.T) {
 					InitBond: big.NewInt(0),
 					GameType: embedded.GameTypeSuperCannonKona,
 				},
+				{
+					Enabled:  false,
+					InitBond: big.NewInt(0),
+					GameType: embedded.GameTypeZKDisputeGame,
+				},
 			},
 			ExtraInstructions: []embedded.ExtraInstruction{
 				{

op-deployer/pkg/deployer/integration_test/shared/shared.go

@@ -296,6 +296,11 @@ func buildV2OPCMUpgradeConfig(t *testing.T, prank, opcmAddr, systemConfigProxy c
 			InitBond: big.NewInt(0),
 			GameType: embedded.GameTypeSuperCannonKona,
 		},
+		{
+			Enabled:  false,
+			InitBond: big.NewInt(0),
+			GameType: embedded.GameTypeZKDisputeGame,
+		},
 	}
 
 	// Sort by game type (required by OPCM)

op-deployer/pkg/deployer/opcm/implementations.go

@@ -58,6 +58,7 @@ type DeployImplementationsOutput struct {
 	PermissionedDisputeGameImpl      common.Address `json:"permissionedDisputeGameImplAddress"`
 	SuperFaultDisputeGameImpl        common.Address `json:"superFaultDisputeGameImplAddress"`
 	SuperPermissionedDisputeGameImpl common.Address `json:"superPermissionedDisputeGameImplAddress"`
+	ZkDisputeGameImpl                common.Address `json:"zkDisputeGameImplAddress" abi:"zkDisputeGameImpl"`
 	StorageSetterImpl                common.Address `json:"storageSetterImplAddress"`
 }
 

op-deployer/pkg/deployer/upgrade/embedded/upgrade.go

@@ -22,6 +22,7 @@ const (
 	GameTypeSuperPermCannon    GameType = 5
 	GameTypeCannonKona         GameType = 8
 	GameTypeSuperCannonKona    GameType = 9
+	GameTypeZKDisputeGame      GameType = 10
 )
 
 var (

op-devstack/sysgo/add_game_type.go

@@ -122,8 +122,8 @@ func addGameTypesForRuntime(
 
 	initBond := eth.GWei(80_000_000).ToBig() // 0.08 ETH
 
-	// OPCMv2 requires all 6 game configs in order:
-	// CANNON, PERMISSIONED_CANNON, CANNON_KONA, SUPER_CANNON, SUPER_PERMISSIONED_CANNON, SUPER_CANNON_KONA.
+	// OPCMv2 requires all 7 game configs in order:
+	// CANNON, PERMISSIONED_CANNON, CANNON_KONA, SUPER_CANNON, SUPER_PERMISSIONED_CANNON, SUPER_CANNON_KONA, ZK_DISPUTE_GAME.
 	cannonPrestate := PrestateForGameType(t, gameTypes.CannonGameType)
 	cannonKonaPrestate := PrestateForGameType(t, gameTypes.CannonKonaGameType)
 
@@ -169,6 +169,11 @@ func addGameTypesForRuntime(
 			InitBond: new(big.Int),
 			GameType: embedded.GameTypeSuperCannonKona,
 		},
+		{
+			Enabled:  false,
+			InitBond: new(big.Int),
+			GameType: embedded.GameTypeZKDisputeGame,
+		},
 	}
 
 	// Zero out init bond for disabled games.

packages/contracts-bedrock/foundry.toml

@@ -19,13 +19,14 @@ optimizer_runs = 999999
 # entire build directory.
 additional_compiler_profiles = [
   { name = "dispute", optimizer_runs = 5000 },
+  { name = "validator", optimizer_runs = 200 },
 ]
 compilation_restrictions = [
   { paths = "src/dispute/FaultDisputeGame.sol", optimizer_runs = 5000 },
   { paths = "src/dispute/PermissionedDisputeGame.sol", optimizer_runs = 5000 },
   { paths = "src/dispute/SuperFaultDisputeGame.sol", optimizer_runs = 5000 },
   { paths = "src/dispute/SuperPermissionedDisputeGame.sol", optimizer_runs = 5000 },
-  { paths = "src/L1/OPContractsManagerStandardValidator.sol", optimizer_runs = 5000 },
+  { paths = "src/L1/OPContractsManagerStandardValidator.sol", optimizer_runs = 200 },
   { paths = "src/L1/opcm/OPContractsManagerV2.sol", optimizer_runs = 5000 },
   { paths = "src/L1/opcm/OPContractsManagerContainer.sol", optimizer_runs = 5000 },
   { paths = "src/L1/opcm/OPContractsManagerMigrator.sol", optimizer_runs = 5000 },

packages/contracts-bedrock/interfaces/L1/IOPContractsManagerStandardValidator.sol

@@ -22,6 +22,7 @@ interface IOPContractsManagerStandardValidator {
         address permissionedDisputeGameImpl;
         address superFaultDisputeGameImpl;
         address superPermissionedDisputeGameImpl;
+        address zkDisputeGameImpl;
     }
 
     struct ValidationInput {
@@ -61,6 +62,7 @@ interface IOPContractsManagerStandardValidator {
     function permissionedDisputeGameImpl() external view returns (address);
     function superFaultDisputeGameImpl() external view returns (address);
     function superPermissionedDisputeGameImpl() external view returns (address);
+    function zkDisputeGameImpl() external view returns (address);
     function optimismMintableERC20FactoryImpl() external view returns (address);
     function optimismPortalImpl() external view returns (address);
     function ethLockboxImpl() external view returns (address);

packages/contracts-bedrock/interfaces/L1/opcm/IOPContractsManagerContainer.sol

@@ -28,6 +28,7 @@ interface IOPContractsManagerContainer {
         address permissionedDisputeGameImpl;
         address superFaultDisputeGameImpl;
         address superPermissionedDisputeGameImpl;
+        address zkDisputeGameImpl;
         address storageSetterImpl;
     }
 

packages/contracts-bedrock/interfaces/L1/opcm/IOPContractsManagerUtils.sol

@@ -7,7 +7,8 @@ import { IAddressManager } from "interfaces/legacy/IAddressManager.sol";
 import { IDisputeGame } from "interfaces/dispute/IDisputeGame.sol";
 import { IAnchorStateRegistry } from "interfaces/dispute/IAnchorStateRegistry.sol";
 import { IDelayedWETH } from "interfaces/dispute/IDelayedWETH.sol";
-import { Claim, GameType } from "src/dispute/lib/Types.sol";
+import { IZKVerifier } from "interfaces/dispute/zk/IZKVerifier.sol";
+import { Claim, Duration, GameType } from "src/dispute/lib/Types.sol";
 
 interface IOPContractsManagerUtils {
     struct ProxyDeployArgs {
@@ -34,6 +35,15 @@ interface IOPContractsManagerUtils {
         address challenger;
     }
 
+    /// @notice Configuration struct for the ZKDisputeGame.
+    struct ZKDisputeGameConfig {
+        Claim absolutePrestate;
+        IZKVerifier verifier;
+        Duration maxChallengeDuration;
+        Duration maxProveDuration;
+        uint256 challengerBond;
+    }
+
     /// @notice Generic dispute game configuration data.
     struct DisputeGameConfig {
         bool enabled;

packages/contracts-bedrock/interfaces/dispute/zk/IZKDisputeGame.sol

@@ -59,6 +59,7 @@ interface IZKDisputeGame is IDisputeGame, ISemver {
     function disputeGameFactory() external view returns (IDisputeGameFactory);
     function totalBonds() external view returns (uint256);
 
+    function __constructor__() external;
     function initialize() external payable;
     function l2SequenceNumber() external pure returns (uint256 l2SequenceNumber_);
     function parentIndex() external pure returns (uint32 parentIndex_);

packages/contracts-bedrock/scripts/deploy/ChainAssertions.sol

@@ -37,6 +37,7 @@ import { IProxyAdminOwnedBase } from "interfaces/universal/IProxyAdminOwnedBase.
 import { IAnchorStateRegistry } from "interfaces/dispute/IAnchorStateRegistry.sol";
 import { IOPContractsManagerV2 } from "interfaces/L1/opcm/IOPContractsManagerV2.sol";
 import { IOPContractsManagerUtils } from "interfaces/L1/opcm/IOPContractsManagerUtils.sol";
+import { IZKDisputeGame } from "interfaces/dispute/zk/IZKDisputeGame.sol";
 
 library ChainAssertions {
     Vm internal constant vm = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
@@ -459,6 +460,13 @@ library ChainAssertions {
         }
     }
 
+    /// @notice Asserts that the ZKDisputeGame implementation is setup correctly.
+    function checkZKDisputeGameImpl(IZKDisputeGame _impl) internal view {
+        console.log("Running chain assertions on the ZKDisputeGame implementation at %s", address(_impl));
+        require(address(_impl) != address(0), "CHECK-ZKDG-10");
+        require(bytes(_impl.version()).length > 0, "CHECK-ZKDG-20");
+    }
+
     /// @notice Converts variables needed from the DeployConfig to a DeployOPChainInput contract
     function dioToContractSet(DeployImplementations.Output memory _output)
         internal

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

@@ -404,7 +404,7 @@ contract Deploy is Deployer {
 
     function getSuperRootDeployInputV2() public view returns (IOPContractsManagerV2.FullConfig memory) {
         IOPContractsManagerUtils.DisputeGameConfig[] memory disputeGameConfigs =
-            new IOPContractsManagerUtils.DisputeGameConfig[](6);
+            new IOPContractsManagerUtils.DisputeGameConfig[](7);
         disputeGameConfigs[0] = IOPContractsManagerUtils.DisputeGameConfig({
             enabled: false,
             initBond: 0,
@@ -451,6 +451,12 @@ contract Deploy is Deployer {
                 })
             )
         });
+        disputeGameConfigs[6] = IOPContractsManagerUtils.DisputeGameConfig({
+            enabled: false,
+            initBond: 0,
+            gameType: GameTypes.ZK_DISPUTE_GAME,
+            gameArgs: bytes("")
+        });
 
         return IOPContractsManagerV2.FullConfig({
             saltMixer: "salt mixer",
@@ -476,7 +482,7 @@ contract Deploy is Deployer {
 
     function getDeployInputV2() public view returns (IOPContractsManagerV2.FullConfig memory) {
         IOPContractsManagerUtils.DisputeGameConfig[] memory disputeGameConfigs =
-            new IOPContractsManagerUtils.DisputeGameConfig[](6);
+            new IOPContractsManagerUtils.DisputeGameConfig[](7);
         disputeGameConfigs[0] = IOPContractsManagerUtils.DisputeGameConfig({
             enabled: false,
             initBond: 0,
@@ -527,6 +533,12 @@ contract Deploy is Deployer {
             gameType: GameTypes.SUPER_CANNON_KONA,
             gameArgs: bytes("")
         });
+        disputeGameConfigs[6] = IOPContractsManagerUtils.DisputeGameConfig({
+            enabled: false,
+            initBond: 0,
+            gameType: GameTypes.ZK_DISPUTE_GAME,
+            gameArgs: bytes("")
+        });
 
         return IOPContractsManagerV2.FullConfig({
             saltMixer: "salt mixer",

packages/contracts-bedrock/scripts/deploy/DeployConfig.s.sol

@@ -96,6 +96,14 @@ contract DeployConfig is Script {
     uint256 public faultGameV2ClockExtension;
     uint256 public faultGameV2MaxClockDuration;
 
+    // ZK Dispute Game Configuration
+    uint256 public zkDisputeGameInitBond;
+    bytes32 public zkDisputeGameAbsolutePrestate;
+    address public zkDisputeGameVerifier;
+    uint256 public zkDisputeGameMaxChallengeDuration;
+    uint256 public zkDisputeGameMaxProveDuration;
+    uint256 public zkDisputeGameChallengerBond;
+
     bool public useUpgradedFork;
     bool public useInterop;
     bytes32 public devFeatureBitmap;
@@ -203,6 +211,13 @@ contract DeployConfig is Script {
         faultGameV2SplitDepth = _readOr(_json, "$.faultGameV2SplitDepth", uint256(30));
         faultGameV2ClockExtension = _readOr(_json, "$.faultGameV2ClockExtension", uint256(10800));
         faultGameV2MaxClockDuration = _readOr(_json, "$.faultGameV2MaxClockDuration", uint256(302400));
+
+        zkDisputeGameInitBond = _readOr(_json, "$.zkDisputeGameInitBond", uint256(1 ether));
+        zkDisputeGameAbsolutePrestate = bytes32(_readOr(_json, "$.zkDisputeGameAbsolutePrestate", uint256(0)));
+        zkDisputeGameVerifier = _readOr(_json, "$.zkDisputeGameVerifier", address(0));
+        zkDisputeGameMaxChallengeDuration = _readOr(_json, "$.zkDisputeGameMaxChallengeDuration", uint256(604800));
+        zkDisputeGameMaxProveDuration = _readOr(_json, "$.zkDisputeGameMaxProveDuration", uint256(259200));
+        zkDisputeGameChallengerBond = _readOr(_json, "$.zkDisputeGameChallengerBond", uint256(1 ether));
     }
 
     function fork() public view returns (Fork fork_) {
@@ -401,6 +416,10 @@ contract DeployConfig is Script {
         faultGameV2SplitDepth = 30;
         faultGameV2ClockExtension = 10800;
         faultGameV2MaxClockDuration = 302400;
+        zkDisputeGameInitBond = 1 ether;
+        zkDisputeGameMaxChallengeDuration = 604800;
+        zkDisputeGameMaxProveDuration = 259200;
+        zkDisputeGameChallengerBond = 1 ether;
         useInterop = false;
         useUpgradedFork = false;
         devFeatureBitmap = bytes32(0);