simpler api for boolean functions

Author: smartcontracts

packages/contracts-bedrock/interfaces/dispute/IAnchorStateRegistry.sol

@@ -9,10 +9,11 @@ import { IOptimismPortal2 } from "interfaces/L1/IOptimismPortal2.sol";
 import { GameType, Hash, OutputRoot } from "src/dispute/lib/Types.sol";
 
 interface IAnchorStateRegistry {
-    error InvalidAnchorGame(string reason);
-    error Unauthorized();
+    error AnchorStateRegistry_Unauthorized();
+    error AnchorStateRegistry_ImproperAnchorGame();
+    error AnchorStateRegistry_InvalidAnchorGame();
 
-    event AnchorNotUpdated(IFaultDisputeGame indexed game, string reason);
+    event AnchorNotUpdated(IFaultDisputeGame indexed game);
     event AnchorUpdated(IFaultDisputeGame indexed game);
     event Initialized(uint8 version);
 
@@ -25,7 +26,7 @@ interface IAnchorStateRegistry {
     function isGameBlacklisted(IDisputeGame _game) external view returns (bool);
     function isGameRespected(IDisputeGame _game) external view returns (bool);
     function isGameRetired(IDisputeGame _game) external view returns (bool);
-    function isGameProper(IDisputeGame _game) external view returns (bool, string memory);
+    function isGameProper(IDisputeGame _game) external view returns (bool);
     function portal() external view returns (IOptimismPortal2);
     function setAnchorState(IFaultDisputeGame _game) external;
     function superchainConfig() external view returns (ISuperchainConfig);

packages/contracts-bedrock/snapshots/abi/AnchorStateRegistry.json

@@ -145,11 +145,6 @@
         "internalType": "bool",
         "name": "",
         "type": "bool"
-      },
-      {
-        "internalType": "string",
-        "name": "",
-        "type": "string"
       }
     ],
     "stateMutability": "view",
@@ -279,12 +274,6 @@
         "internalType": "contract IFaultDisputeGame",
         "name": "game",
         "type": "address"
-      },
-      {
-        "indexed": false,
-        "internalType": "string",
-        "name": "reason",
-        "type": "string"
       }
     ],
     "name": "AnchorNotUpdated",
@@ -317,19 +306,18 @@
     "type": "event"
   },
   {
-    "inputs": [
-      {
-        "internalType": "string",
-        "name": "reason",
-        "type": "string"
-      }
-    ],
-    "name": "InvalidAnchorGame",
+    "inputs": [],
+    "name": "AnchorStateRegistry_ImproperAnchorGame",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "AnchorStateRegistry_InvalidAnchorGame",
     "type": "error"
   },
   {
     "inputs": [],
-    "name": "Unauthorized",
+    "name": "AnchorStateRegistry_Unauthorized",
     "type": "error"
   }
 ]

packages/contracts-bedrock/snapshots/semver-lock.json

@@ -152,8 +152,8 @@
     "sourceCodeHash": "0xb7b0a06cd971c4647247dc19ce997d0c64a73e87c81d30731da9cf9efa1b952a"
   },
   "src/dispute/AnchorStateRegistry.sol": {
-    "initCodeHash": "0x00a96ace2161b2ede09cf2082d934fe60769c0120c34d61a22a953e8d6a32860",
-    "sourceCodeHash": "0xde0d10f630e7a8911e43ea6a8545f9d1767ae356469d2a2eabbdcb029b8659d9"
+    "initCodeHash": "0xfbeeac40d86d13e71c7add66eef6357576a93b6a175c9cff6ec6ef587fe3acc4",
+    "sourceCodeHash": "0xe299ca0d3a1c3a22e31e94db5e62122120c6aa081bbc2424367022e77b826348"
   },
   "src/dispute/DelayedWETH.sol": {
     "initCodeHash": "0x759d7f9c52b7c13ce4502f39dae3a75d130c6278240cde0b60ae84616aa2bd48",

packages/contracts-bedrock/src/dispute/AnchorStateRegistry.sol

@@ -6,8 +6,6 @@ import { Initializable } from "@openzeppelin/contracts/proxy/utils/Initializable
 
 // Libraries
 import { GameType, OutputRoot, Claim, GameStatus, Hash } from "src/dispute/lib/Types.sol";
-import { Unauthorized } from "src/libraries/errors/CommonErrors.sol";
-import { InvalidAnchorGame } from "src/dispute/lib/Errors.sol";
 
 // Interfaces
 import { ISemver } from "interfaces/universal/ISemver.sol";
@@ -44,11 +42,22 @@ contract AnchorStateRegistry is Initializable, ISemver {
     OutputRoot internal startingAnchorRoot;
 
     /// @notice Emitted when an anchor state is not updated.
-    event AnchorNotUpdated(IFaultDisputeGame indexed game, string reason);
+    /// @param game Game that was not used as the new anchor game.
+    event AnchorNotUpdated(IFaultDisputeGame indexed game);
 
     /// @notice Emitted when an anchor state is updated.
+    /// @param game Game that was used as the new anchor game.
     event AnchorUpdated(IFaultDisputeGame indexed game);
 
+    /// @notice Thrown when an unauthorized caller attempts to set the anchor state.
+    error AnchorStateRegistry_Unauthorized();
+
+    /// @notice Thrown when an improper anchor game is provided.
+    error AnchorStateRegistry_ImproperAnchorGame();
+
+    /// @notice Thrown when an invalid anchor game is provided.
+    error AnchorStateRegistry_InvalidAnchorGame();
+
     /// @notice Constructor to disable initializers.
     constructor() {
         _disableInitializers();
@@ -138,28 +147,28 @@ contract AnchorStateRegistry is Initializable, ISemver {
     ///         DO NOT USE THIS FUNCTION ALONE TO DETERMINE IF A ROOT CLAIM IS VALID.
     /// @param _game The game to check.
     /// @return Whether the game is a proper game.
-    /// @return Reason why the game is not a proper game.
-    function isGameProper(IDisputeGame _game) public view returns (bool, string memory) {
+    function isGameProper(IDisputeGame _game) public view returns (bool) {
+        // Must be registered in the DisputeGameFactory.
         if (!isGameRegistered(_game)) {
-            return (false, "game not factory registered");
+            return false;
         }
 
         // Must be respected game type.
         if (!isGameRespected(_game)) {
-            return (false, "game type not respected");
+            return false;
         }
 
         // Must not be blacklisted.
         if (isGameBlacklisted(_game)) {
-            return (false, "game blacklisted");
+            return false;
         }
 
         // Must be created at or after the respectedGameTypeUpdatedAt timestamp.
         if (isGameRetired(_game)) {
-            return (false, "game retired");
+            return false;
         }
 
-        return (true, "");
+        return true;
     }
 
     /// @notice Callable by FaultDisputeGame contracts to update the anchor state. Pulls the anchor state directly from
@@ -170,22 +179,21 @@ contract AnchorStateRegistry is Initializable, ISemver {
         IFaultDisputeGame game = IFaultDisputeGame(msg.sender);
 
         // Check if the game is a proper game.
-        (bool isProper, string memory reason) = isGameProper(game);
-        if (!isProper) {
-            emit AnchorNotUpdated(game, reason);
+        if (!isGameProper(game)) {
+            emit AnchorNotUpdated(game);
             return;
         }
 
         // Must be a game that resolved in favor of the state.
         if (game.status() != GameStatus.DEFENDER_WINS) {
-            emit AnchorNotUpdated(game, "game not defender wins");
+            emit AnchorNotUpdated(game);
             return;
         }
 
         // No need to update anything if the anchor state is already newer.
         (, uint256 anchorL2BlockNumber) = getAnchorRoot();
         if (game.l2BlockNumber() <= anchorL2BlockNumber) {
-            emit AnchorNotUpdated(game, "game not newer than anchor state");
+            emit AnchorNotUpdated(game);
             return;
         }
 
@@ -197,17 +205,19 @@ contract AnchorStateRegistry is Initializable, ISemver {
     /// @notice Sets the anchor state given the game.
     /// @param _game The game to set the anchor state for.
     function setAnchorState(IFaultDisputeGame _game) external {
-        if (msg.sender != superchainConfig.guardian()) revert Unauthorized();
+        // Function can only be triggered by the guardian.
+        if (msg.sender != superchainConfig.guardian()) {
+            revert AnchorStateRegistry_Unauthorized();
+        }
 
         // Check if the game is a proper game.
-        (bool isProper, string memory reason) = isGameProper(_game);
-        if (!isProper) {
-            revert InvalidAnchorGame(reason);
+        if (!isGameProper(_game)) {
+            revert AnchorStateRegistry_ImproperAnchorGame();
         }
 
         // The game must have resolved in favor of the root claim.
         if (_game.status() != GameStatus.DEFENDER_WINS) {
-            revert InvalidAnchorGame("game not defender wins");
+            revert AnchorStateRegistry_InvalidAnchorGame();
         }
 
         // Update the anchor game.

packages/contracts-bedrock/src/dispute/lib/Errors.sol

@@ -127,10 +127,3 @@ error L2BlockNumberChallenged();
 
 /// @notice Thrown when an unauthorized address attempts to interact with the game.
 error BadAuth();
-
-////////////////////////////////////////////////////////////////
-//              `AnchorStateRegistry` Errors                  //
-////////////////////////////////////////////////////////////////
-
-/// @notice Thrown when an invalid anchor game is provided.
-error InvalidAnchorGame(string reason);