Add secondary game

packages/contracts-bedrock/semver-lock.json

@@ -24,6 +24,7 @@
   "src/dispute/BlockOracle.sol": "0x7e724b1ee0116dfd744f556e6237af449c2f40c6426d6f1462ae2a47589283bb",
   "src/dispute/DisputeGameFactory.sol": "0xfdfa141408d7f8de7e230ff4bef088e30d0e4d569ca743d60d292abdd21ff270",
   "src/dispute/FaultDisputeGame.sol": "0x7ac7553a47d96a4481a6b95363458bed5f160112b647829c4defc134fa178d9a",
+  "src/dispute/OutputBisectionGame.sol": "0xc5db24fcae2a668852f2a8a283483b75ca598f1d7169bd50970ab6c8e4a1aeb4",
   "src/legacy/DeployerWhitelist.sol": "0x0a6840074734c9d167321d3299be18ef911a415e4c471fa92af7d6cfaa8336d4",
   "src/legacy/L1BlockNumber.sol": "0x20d83a636c5e2067fca8c0ed505b295174e6eddb25960d8705e6b6fea8e77fa6",
   "src/legacy/LegacyMessagePasser.sol": "0x80f355c9710af586f58cf6a86d1925e0073d1e504d0b3d814284af1bafe4dece",

packages/contracts-bedrock/src/dispute/interfaces/IOutputBisectionGame.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+import { IDisputeGame } from "./IDisputeGame.sol";
+
+import "src/libraries/DisputeTypes.sol";
+
+/// @title IOutputBisectionGame
+/// @notice The interface for a fault proof backed dispute game.
+interface IOutputBisectionGame is IDisputeGame {
+    /// @notice The `ClaimData` struct represents the data associated with a Claim.
+    /// @dev TODO(clabby): Add bond ID information.
+    struct ClaimData {
+        uint32 parentIndex;
+        bool countered;
+        Claim claim;
+        Position position;
+        Clock clock;
+    }
+
+    /// @notice Emitted when a new claim is added to the DAG by `claimant`
+    /// @param parentIndex The index within the `claimData` array of the parent claim
+    /// @param claim The claim being added
+    /// @param claimant The address of the claimant
+    event Move(uint256 indexed parentIndex, Claim indexed claim, address indexed claimant);
+
+    /// @notice Attack a disagreed upon `Claim`.
+    /// @param _parentIndex Index of the `Claim` to attack in the `claimData` array.
+    /// @param _claim The `Claim` at the relative attack position.
+    function attack(uint256 _parentIndex, Claim _claim) external payable;
+
+    /// @notice Defend an agreed upon `Claim`.
+    /// @param _parentIndex Index of the claim to defend in the `claimData` array.
+    /// @param _claim The `Claim` at the relative defense position.
+    function defend(uint256 _parentIndex, Claim _claim) external payable;
+
+    /// @notice Perform an instruction step via an on-chain fault proof processor.
+    /// @dev This function should point to a fault proof processor in order to execute
+    ///      a step in the fault proof program on-chain. The interface of the fault proof
+    ///      processor contract should adhere to the `IBigStepper` interface.
+    /// @param _claimIndex The index of the challenged claim within `claimData`.
+    /// @param _isAttack Whether or not the step is an attack or a defense.
+    /// @param _stateData The stateData of the step is the preimage of the claim at the given
+    ///        prestate, which is at `_stateIndex` if the move is an attack and `_claimIndex` if
+    ///        the move is a defense. If the step is an attack on the first instruction, it is
+    ///        the absolute prestate of the fault proof VM.
+    /// @param _proof Proof to access memory nodes in the VM's merkle state tree.
+    function step(uint256 _claimIndex, bool _isAttack, bytes calldata _stateData, bytes calldata _proof) external;
+
+    /// @notice Posts the requested local data to the VM's `PreimageOralce`.
+    /// @param _ident The local identifier of the data to post.
+    /// @param _execLeafIdx The index of the leaf claim in an execution subgame that requires the local data for a step.
+    /// @param _partOffset The offset of the data to post.
+    function addLocalData(uint256 _ident, uint256 _execLeafIdx, uint256 _partOffset) external;
+
+    /// @notice Resolves the subgame rooted at the given claim index.
+    /// @dev This function must be called bottom-up in the DAG
+    ///      A subgame is a tree of claims that has a maximum depth of 1.
+    ///      A subgame root claims is valid if, and only if, all of its child claims are invalid.
+    ///      At the deepest level in the DAG, a claim is invalid if there's a successful step against it.
+    /// @param _claimIndex The index of the subgame root claim to resolve.
+    function resolveClaim(uint256 _claimIndex) external payable;
+
+    /// @notice An L1 block hash that contains the disputed output root, fetched from the
+    ///         `BlockOracle` and verified by referencing the timestamp associated with the
+    ///         first L2 Output Proposal in the `L2OutputOracle` that contains the disputed
+    ///         L2 block number.
+    function l1Head() external view returns (Hash l1Head_);
+
+    /// @notice The l2BlockNumber of the disputed output root in the `L2OutputOracle`.
+    function l2BlockNumber() external view returns (uint256 l2BlockNumber_);
+}

packages/contracts-bedrock/src/libraries/DisputeErrors.sol

@@ -72,6 +72,14 @@ error OutOfOrderResolution();
 /// @notice Thrown when resolving a claim that has already been resolved.
 error ClaimAlreadyResolved();
 
+/// @notice Thrown when a parent output root is attempted to be found on a claim that is in
+///         the output root portion of the tree.
+error ClaimAboveSplit();
+
+/// @notice Thrown on deployment if the split depth is greater than or equal to the max
+///         depth of the game.
+error InvalidSplitDepth();
+
 ////////////////////////////////////////////////////////////////
 //              `AttestationDisputeGame` Errors               //
 ////////////////////////////////////////////////////////////////