@arbitrum/nitro-contracts 2.1.1-beta.0 → 3.0.0-alpha.1

package/src/challengeV2/IEdgeChallengeManager.sol

@@ -0,0 +1,233 @@
+// Copyright 2023, Offchain Labs, Inc.
+// For license information, see https://github.com/offchainlabs/bold/blob/main/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+//
+pragma solidity ^0.8.0;
+
+import "./IAssertionChain.sol";
+import "./libraries/Structs.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+/// @title EdgeChallengeManager interface
+interface IEdgeChallengeManager {
+    /// @notice Initialize the EdgeChallengeManager. EdgeChallengeManagers are upgradeable
+    ///         so use the initializer paradigm
+    /// @param _assertionChain              The assertion chain contract
+    /// @param _challengePeriodBlocks       The amount of cumulative time an edge must spend unrivaled before it can be confirmed
+    ///                                     This should be the censorship period + the cumulative amount of time needed to do any
+    ///                                     offchain calculation. We currently estimate around 10 mins for each layer zero edge and 1
+    ///                                     one minute for each other edge.
+    /// @param _oneStepProofEntry           The one step proof logic
+    /// @param layerZeroBlockEdgeHeight     The end height of layer zero edges of type Block
+    /// @param layerZeroBigStepEdgeHeight   The end height of layer zero edges of type BigStep
+    /// @param layerZeroSmallStepEdgeHeight The end height of layer zero edges of type SmallStep
+    /// @param _stakeToken                  The token that stake will be provided in when creating zero layer block edges
+    /// @param _excessStakeReceiver         The address that excess stake will be sent to when 2nd+ block edge is created
+    /// @param _numBigStepLevel             The number of bigstep levels
+    /// @param _stakeAmounts                The stake amount for each level. (first element is for block level)
+    function initialize(
+        IAssertionChain _assertionChain,
+        uint64 _challengePeriodBlocks,
+        IOneStepProofEntry _oneStepProofEntry,
+        uint256 layerZeroBlockEdgeHeight,
+        uint256 layerZeroBigStepEdgeHeight,
+        uint256 layerZeroSmallStepEdgeHeight,
+        IERC20 _stakeToken,
+        address _excessStakeReceiver,
+        uint8 _numBigStepLevel,
+        uint256[] calldata _stakeAmounts
+    ) external;
+
+    function challengePeriodBlocks() external view returns (uint64);
+
+    /// @notice The one step proof resolver used to decide between rival SmallStep edges of length 1
+    function oneStepProofEntry() external view returns (IOneStepProofEntry);
+
+    /// @notice Performs necessary checks and creates a new layer zero edge
+    /// @param args             Edge creation args
+    function createLayerZeroEdge(
+        CreateEdgeArgs calldata args
+    ) external returns (bytes32);
+
+    /// @notice Bisect an edge. This creates two child edges:
+    ///         lowerChild: has the same start root and height as this edge, but a different end root and height
+    ///         upperChild: has the same end root and height as this edge, but a different start root and height
+    ///         The lower child end root and height are equal to the upper child start root and height. This height
+    ///         is the mandatoryBisectionHeight.
+    ///         The lower child may already exist, however it's not possible for the upper child to exist as that would
+    ///         mean that the edge has already been bisected
+    /// @param edgeId               Edge to bisect
+    /// @param bisectionHistoryRoot The new history root to be used in the lower and upper children
+    /// @param prefixProof          A proof to show that the bisectionHistoryRoot commits to a prefix of the current endHistoryRoot
+    /// @return lowerChildId        The id of the newly created lower child edge
+    /// @return upperChildId        The id of the newly created upper child edge
+    function bisectEdge(
+        bytes32 edgeId,
+        bytes32 bisectionHistoryRoot,
+        bytes calldata prefixProof
+    ) external returns (bytes32, bytes32);
+
+    /// @notice An edge can be confirmed if the total amount of time it and a single chain of its direct ancestors
+    ///         has spent unrivaled is greater than the challenge period.
+    /// @dev    Edges inherit time from their parents, so the sum of unrivaled timers is compared against the threshold.
+    ///         Given that an edge cannot become unrivaled after becoming rivaled, once the threshold is passed
+    ///         it will always remain passed. The direct ancestors of an edge are linked by parent-child links for edges
+    ///         of the same level, and claimId-edgeId links for zero layer edges that claim an edge in the level below.
+    ///         This method also includes the amount of time the assertion being claimed spent without a sibling
+    /// @param edgeId                   The id of the edge to confirm
+    function confirmEdgeByTime(
+        bytes32 edgeId,
+        AssertionStateData calldata claimStateData
+    ) external;
+
+    /// @notice Update multiple edges' timer cache by their children. Equivalent to calling updateTimerCacheByChildren for each edge.
+    ///         May update timer cache above maximum if the last edge's timer cache was below maximumCachedTime.
+    ///         Revert when the last edge's timer cache is already equal to or above maximumCachedTime.
+    /// @param edgeIds           The ids of the edges to update
+    /// @param maximumCachedTime The maximum amount of cached time allowed on the last edge (β∗)
+    function multiUpdateTimeCacheByChildren(
+        bytes32[] calldata edgeIds,
+        uint256 maximumCachedTime
+    ) external;
+
+    /// @notice Update an edge's timer cache by its children.
+    ///         Sets the edge's timer cache to its timeUnrivaled + (minimum timer cache of its children).
+    ///         May update timer cache above maximum if the last edge's timer cache was below maximumCachedTime.
+    ///         Revert when the edge's timer cache is already equal to or above maximumCachedTime.
+    /// @param edgeId            The id of the edge to update
+    /// @param maximumCachedTime The maximum amount of cached time allowed on the edge (β∗)
+    function updateTimerCacheByChildren(bytes32 edgeId, uint256 maximumCachedTime) external;
+
+    /// @notice Given a one step fork edge and an edge with matching claim id,
+    ///         set the one step fork edge's timer cache to its timeUnrivaled + claiming edge's timer cache.
+    ///         May update timer cache above maximum if the last edge's timer cache was below maximumCachedTime.
+    ///         Revert when the edge's timer cache is already equal to or above maximumCachedTime.
+    /// @param edgeId            The id of the edge to update
+    /// @param claimingEdgeId    The id of the edge which has a claimId equal to edgeId
+    /// @param maximumCachedTime The maximum amount of cached time allowed on the edge (β∗)
+    function updateTimerCacheByClaim(
+        bytes32 edgeId,
+        bytes32 claimingEdgeId,
+        uint256 maximumCachedTime
+    ) external;
+
+    /// @notice Confirm an edge by executing a one step proof
+    /// @dev    One step proofs can only be executed against edges that have length one and of type SmallStep
+    /// @param edgeId                       The id of the edge to confirm
+    /// @param oneStepData                  Input data to the one step proof
+    /// @param prevConfig                     Data about the config set in prev
+    /// @param beforeHistoryInclusionProof  Proof that the state which is the start of the edge is committed to by the startHistoryRoot
+    /// @param afterHistoryInclusionProof   Proof that the state which is the end of the edge is committed to by the endHistoryRoot
+    function confirmEdgeByOneStepProof(
+        bytes32 edgeId,
+        OneStepData calldata oneStepData,
+        ConfigData calldata prevConfig,
+        bytes32[] calldata beforeHistoryInclusionProof,
+        bytes32[] calldata afterHistoryInclusionProof
+    ) external;
+
+    /// @notice When zero layer block edges are created a stake is also provided
+    ///         The stake on this edge can be refunded if the edge is confirme
+    function refundStake(
+        bytes32 edgeId
+    ) external;
+
+    /// @notice Zero layer edges have to be a fixed height.
+    ///         This function returns the end height for a given edge type
+    function getLayerZeroEndHeight(
+        EdgeType eType
+    ) external view returns (uint256);
+
+    /// @notice Calculate the unique id of an edge
+    /// @param level            The level of the edge
+    /// @param originId         The origin id of the edge
+    /// @param startHeight      The start height of the edge
+    /// @param startHistoryRoot The start history root of the edge
+    /// @param endHeight        The end height of the edge
+    /// @param endHistoryRoot   The end history root of the edge
+    function calculateEdgeId(
+        uint8 level,
+        bytes32 originId,
+        uint256 startHeight,
+        bytes32 startHistoryRoot,
+        uint256 endHeight,
+        bytes32 endHistoryRoot
+    ) external pure returns (bytes32);
+
+    /// @notice Calculate the mutual id of the edge
+    ///         Edges that are rivals share the same mutual id
+    /// @param level            The level of the edge
+    /// @param originId         The origin id of the edge
+    /// @param startHeight      The start height of the edge
+    /// @param startHistoryRoot The start history root of the edge
+    /// @param endHeight        The end height of the edge
+    function calculateMutualId(
+        uint8 level,
+        bytes32 originId,
+        uint256 startHeight,
+        bytes32 startHistoryRoot,
+        uint256 endHeight
+    ) external pure returns (bytes32);
+
+    /// @notice Has the edge already been stored in the manager
+    function edgeExists(
+        bytes32 edgeId
+    ) external view returns (bool);
+
+    /// @notice Get full edge data for an edge
+    function getEdge(
+        bytes32 edgeId
+    ) external view returns (ChallengeEdge memory);
+
+    /// @notice The length of the edge, from start height to end height
+    function edgeLength(
+        bytes32 edgeId
+    ) external view returns (uint256);
+
+    /// @notice Does this edge currently have one or more rivals
+    ///         Rival edges share the same mutual id
+    function hasRival(
+        bytes32 edgeId
+    ) external view returns (bool);
+
+    /// @notice The confirmed rival of this mutual id
+    ///         Returns 0 if one does not exist
+    function confirmedRival(
+        bytes32 mutualId
+    ) external view returns (bytes32);
+
+    /// @notice Does the edge have at least one rival, and it has length one
+    function hasLengthOneRival(
+        bytes32 edgeId
+    ) external view returns (bool);
+
+    /// @notice The amount of time this edge has spent without rivals
+    ///         This value is increasing whilst an edge is unrivaled, once a rival is created
+    ///         it is fixed. If an edge has rivals from the moment it is created then it will have
+    ///         a zero time unrivaled
+    function timeUnrivaled(
+        bytes32 edgeId
+    ) external view returns (uint256);
+
+    /// @notice Get the id of the prev assertion that this edge is originates from
+    /// @dev    Uses the parent chain to traverse upwards SmallStep->BigStep->Block->Assertion
+    ///         until it gets to the origin assertion
+    function getPrevAssertionHash(
+        bytes32 edgeId
+    ) external view returns (bytes32);
+
+    /// @notice Fetch the raw first rival record for the given mutual id
+    /// @dev    Returns 0 if there is no edge with the given mutual id
+    ///         Returns a magic value if there is one edge but it is unrivaled
+    ///         Returns the id of the second edge created with the mutual id, if > 1 exists
+    function firstRival(
+        bytes32 mutualId
+    ) external view returns (bytes32);
+
+    /// @notice True if an account has made a layer zero edge with the given mutual id.
+    ///         This is only tracked when the validator whitelist is enabled
+    function hasMadeLayerZeroRival(
+        address account,
+        bytes32 mutualId
+    ) external view returns (bool);
+}

package/src/challengeV2/libraries/ArrayUtilsLib.sol

@@ -0,0 +1,61 @@
+// Copyright 2023, Offchain Labs, Inc.
+// For license information, see https://github.com/offchainlabs/bold/blob/main/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+//
+pragma solidity ^0.8.17;
+
+/// @title  Array utils library
+/// @notice Utils for working with bytes32 arrays
+library ArrayUtilsLib {
+    /// @notice Append an item to the end of an array
+    /// @param arr      The array to append to
+    /// @param newItem  The item to append
+    function append(
+        bytes32[] memory arr,
+        bytes32 newItem
+    ) internal pure returns (bytes32[] memory) {
+        bytes32[] memory clone = new bytes32[](arr.length + 1);
+        for (uint256 i = 0; i < arr.length; i++) {
+            clone[i] = arr[i];
+        }
+        clone[clone.length - 1] = newItem;
+        return clone;
+    }
+
+    /// @notice Get a slice of an existing array
+    /// @dev    End index exlusive so slice(arr, 0, 5) gets the first 5 elements of arr
+    /// @param arr          Array to slice
+    /// @param startIndex   The start index of the slice in the original array - inclusive
+    /// @param endIndex     The end index of the slice in the original array - exlusive
+    function slice(
+        bytes32[] memory arr,
+        uint256 startIndex,
+        uint256 endIndex
+    ) internal pure returns (bytes32[] memory) {
+        require(startIndex < endIndex, "Start not less than end");
+        require(endIndex <= arr.length, "End not less or equal than length");
+
+        bytes32[] memory newArr = new bytes32[](endIndex - startIndex);
+        for (uint256 i = startIndex; i < endIndex; i++) {
+            newArr[i - startIndex] = arr[i];
+        }
+        return newArr;
+    }
+
+    /// @notice Concatenated to arrays
+    /// @param arr1 First array
+    /// @param arr1 Second array
+    function concat(
+        bytes32[] memory arr1,
+        bytes32[] memory arr2
+    ) internal pure returns (bytes32[] memory) {
+        bytes32[] memory full = new bytes32[](arr1.length + arr2.length);
+        for (uint256 i = 0; i < arr1.length; i++) {
+            full[i] = arr1[i];
+        }
+        for (uint256 i = 0; i < arr2.length; i++) {
+            full[arr1.length + i] = arr2[i];
+        }
+        return full;
+    }
+}

package/src/challengeV2/libraries/ChallengeEdgeLib.sol

@@ -0,0 +1,277 @@
+// Copyright 2023, Offchain Labs, Inc.
+// For license information, see https://github.com/offchainlabs/bold/blob/main/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+//
+pragma solidity ^0.8.17;
+
+import "./Enums.sol";
+import "./ChallengeErrors.sol";
+import "./Structs.sol";
+
+library ChallengeEdgeLib {
+    /// @notice Common checks to do when adding an edge
+    function newEdgeChecks(
+        bytes32 originId,
+        bytes32 startHistoryRoot,
+        uint256 startHeight,
+        bytes32 endHistoryRoot,
+        uint256 endHeight
+    ) internal pure {
+        if (originId == 0) {
+            revert EmptyOriginId();
+        }
+        if (endHeight <= startHeight) {
+            revert InvalidHeights(startHeight, endHeight);
+        }
+        if (startHistoryRoot == 0) {
+            revert EmptyStartRoot();
+        }
+        if (endHistoryRoot == 0) {
+            revert EmptyEndRoot();
+        }
+    }
+
+    /// @notice Create a new layer zero edge. These edges make claims about length one edges in the level
+    ///         below. Creating a layer zero edge also requires placing a mini stake, so information
+    ///         about that staker is also stored on this edge.
+    function newLayerZeroEdge(
+        bytes32 originId,
+        bytes32 startHistoryRoot,
+        uint256 startHeight,
+        bytes32 endHistoryRoot,
+        uint256 endHeight,
+        bytes32 claimId,
+        address staker,
+        uint8 level
+    ) internal view returns (ChallengeEdge memory) {
+        if (staker == address(0)) {
+            revert EmptyStaker();
+        }
+        if (claimId == 0) {
+            revert EmptyClaimId();
+        }
+
+        newEdgeChecks(originId, startHistoryRoot, startHeight, endHistoryRoot, endHeight);
+
+        return ChallengeEdge({
+            originId: originId,
+            startHeight: startHeight,
+            startHistoryRoot: startHistoryRoot,
+            endHeight: endHeight,
+            endHistoryRoot: endHistoryRoot,
+            lowerChildId: 0,
+            upperChildId: 0,
+            createdAtBlock: uint64(block.number),
+            claimId: claimId,
+            staker: staker,
+            status: EdgeStatus.Pending,
+            level: level,
+            refunded: false,
+            confirmedAtBlock: 0,
+            totalTimeUnrivaledCache: 0
+        });
+    }
+
+    /// @notice Creates a new child edge. All edges except layer zero edges are child edges.
+    ///         These are edges that are created by bisection, and have parents rather than claims.
+    function newChildEdge(
+        bytes32 originId,
+        bytes32 startHistoryRoot,
+        uint256 startHeight,
+        bytes32 endHistoryRoot,
+        uint256 endHeight,
+        uint8 level
+    ) internal view returns (ChallengeEdge memory) {
+        newEdgeChecks(originId, startHistoryRoot, startHeight, endHistoryRoot, endHeight);
+
+        return ChallengeEdge({
+            originId: originId,
+            startHeight: startHeight,
+            startHistoryRoot: startHistoryRoot,
+            endHeight: endHeight,
+            endHistoryRoot: endHistoryRoot,
+            lowerChildId: 0,
+            upperChildId: 0,
+            createdAtBlock: uint64(block.number),
+            claimId: 0,
+            staker: address(0),
+            status: EdgeStatus.Pending,
+            level: level,
+            refunded: false,
+            confirmedAtBlock: 0,
+            totalTimeUnrivaledCache: 0
+        });
+    }
+
+    /// @notice The "mutualId" of an edge. A mutual id is a hash of all the data that is shared by rivals.
+    ///         Rivals have the same start height, start history root and end height. They also have the same origin id and level.
+    ///         The difference between rivals is that they have a different endHistoryRoot, so that information
+    ///         is not included in this hash.
+    function mutualIdComponent(
+        uint8 level,
+        bytes32 originId,
+        uint256 startHeight,
+        bytes32 startHistoryRoot,
+        uint256 endHeight
+    ) internal pure returns (bytes32) {
+        return
+            keccak256(abi.encodePacked(level, originId, startHeight, startHistoryRoot, endHeight));
+    }
+
+    /// @notice The "mutualId" of an edge. A mutual id is a hash of all the data that is shared by rivals.
+    ///         Rivals have the same start height, start history root and end height. They also have the same origin id and level.
+    ///         The difference between rivals is that they have a different endHistoryRoot, so that information
+    ///         is not included in this hash.
+    function mutualId(
+        ChallengeEdge storage ce
+    ) internal view returns (bytes32) {
+        return mutualIdComponent(
+            ce.level, ce.originId, ce.startHeight, ce.startHistoryRoot, ce.endHeight
+        );
+    }
+
+    function mutualIdMem(
+        ChallengeEdge memory ce
+    ) internal pure returns (bytes32) {
+        return mutualIdComponent(
+            ce.level, ce.originId, ce.startHeight, ce.startHistoryRoot, ce.endHeight
+        );
+    }
+
+    /// @notice The id of an edge. Edges are uniquely identified by their id, and commit to the same information
+    function idComponent(
+        uint8 level,
+        bytes32 originId,
+        uint256 startHeight,
+        bytes32 startHistoryRoot,
+        uint256 endHeight,
+        bytes32 endHistoryRoot
+    ) internal pure returns (bytes32) {
+        return keccak256(
+            abi.encodePacked(
+                mutualIdComponent(level, originId, startHeight, startHistoryRoot, endHeight),
+                endHistoryRoot
+            )
+        );
+    }
+
+    /// @notice The id of an edge. Edges are uniquely identified by their id, and commit to the same information
+    /// @dev    This separate idMem method is to be explicit about when ChallengeEdges are copied into memory. It is
+    ///         possible to pass a storage edge to this method and the id be computed correctly, but that would load
+    ///         the whole struct into memory, so we're explicit here that this should be used for edges already in memory.
+    function idMem(
+        ChallengeEdge memory edge
+    ) internal pure returns (bytes32) {
+        return idComponent(
+            edge.level,
+            edge.originId,
+            edge.startHeight,
+            edge.startHistoryRoot,
+            edge.endHeight,
+            edge.endHistoryRoot
+        );
+    }
+
+    /// @notice The id of an edge. Edges are uniquely identified by their id, and commit to the same information
+    function id(
+        ChallengeEdge storage edge
+    ) internal view returns (bytes32) {
+        return idComponent(
+            edge.level,
+            edge.originId,
+            edge.startHeight,
+            edge.startHistoryRoot,
+            edge.endHeight,
+            edge.endHistoryRoot
+        );
+    }
+
+    /// @notice Does this edge exist in storage
+    function exists(
+        ChallengeEdge storage edge
+    ) internal view returns (bool) {
+        // All edges have a createdAtBlock number
+        return edge.createdAtBlock != 0;
+    }
+
+    /// @notice The length of this edge - difference between the start and end heights
+    function length(
+        ChallengeEdge storage edge
+    ) internal view returns (uint256) {
+        uint256 len = edge.endHeight - edge.startHeight;
+        // It's impossible for a zero length edge to exist
+        if (len == 0) {
+            revert EdgeNotExists(ChallengeEdgeLib.id(edge));
+        }
+        return len;
+    }
+
+    /// @notice Set the children of an edge
+    /// @dev    Children can only be set once
+    function setChildren(
+        ChallengeEdge storage edge,
+        bytes32 lowerChildId,
+        bytes32 upperChildId
+    ) internal {
+        if (edge.lowerChildId != 0 || edge.upperChildId != 0) {
+            revert ChildrenAlreadySet(
+                ChallengeEdgeLib.id(edge), edge.lowerChildId, edge.upperChildId
+            );
+        }
+        edge.lowerChildId = lowerChildId;
+        edge.upperChildId = upperChildId;
+    }
+
+    /// @notice Set the status of an edge to Confirmed
+    /// @dev    Only Pending edges can be confirmed
+    function setConfirmed(
+        ChallengeEdge storage edge
+    ) internal {
+        if (edge.status != EdgeStatus.Pending) {
+            revert EdgeNotPending(ChallengeEdgeLib.id(edge), edge.status);
+        }
+        edge.status = EdgeStatus.Confirmed;
+        edge.confirmedAtBlock = uint64(block.number);
+    }
+
+    /// @notice Is the edge a layer zero edge.
+    function isLayerZero(
+        ChallengeEdge storage edge
+    ) internal view returns (bool) {
+        return edge.claimId != 0 && edge.staker != address(0);
+    }
+
+    /// @notice Set the refunded flag of an edge
+    /// @dev    Checks internally that edge is confirmed, layer zero edge and hasnt been refunded already
+    function setRefunded(
+        ChallengeEdge storage edge
+    ) internal {
+        if (edge.status != EdgeStatus.Confirmed) {
+            revert EdgeNotConfirmed(ChallengeEdgeLib.id(edge), edge.status);
+        }
+        if (!isLayerZero(edge)) {
+            revert EdgeNotLayerZero(ChallengeEdgeLib.id(edge), edge.staker, edge.claimId);
+        }
+        if (edge.refunded == true) {
+            revert EdgeAlreadyRefunded(ChallengeEdgeLib.id(edge));
+        }
+
+        edge.refunded = true;
+    }
+
+    /// @notice Returns the edge type for a given level, given the total number of big step levels
+    function levelToType(
+        uint8 level,
+        uint8 numBigStepLevels
+    ) internal pure returns (EdgeType eType) {
+        if (level == 0) {
+            return EdgeType.Block;
+        } else if (level <= numBigStepLevels) {
+            return EdgeType.BigStep;
+        } else if (level == numBigStepLevels + 1) {
+            return EdgeType.SmallStep;
+        } else {
+            revert LevelTooHigh(level, numBigStepLevels);
+        }
+    }
+}

package/src/challengeV2/libraries/ChallengeErrors.sol

@@ -0,0 +1,108 @@
+// Copyright 2023, Offchain Labs, Inc.
+// For license information, see https://github.com/offchainlabs/bold/blob/main/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+//
+pragma solidity ^0.8.17;
+
+import "./Enums.sol";
+
+/// @dev The edge is not currently stored
+error EdgeNotExists(bytes32 edgeId);
+/// @dev The edge has already been stored
+error EdgeAlreadyExists(bytes32 edgeId);
+/// @dev The provided assertion hash was empty
+error AssertionHashEmpty();
+/// @dev The assertion hashes are not the same, but should have been
+error AssertionHashMismatch(bytes32 h1, bytes32 h2);
+/// @dev The assertion is not currently pending
+error AssertionNotPending();
+/// @dev The assertion has no sibling
+error AssertionNoSibling();
+/// @dev The edge type specific proof data is empty
+error EmptyEdgeSpecificProof();
+/// @dev The start machine status is empty
+error EmptyStartMachineStatus();
+/// @dev The end machine status is empty
+error EmptyEndMachineStatus();
+/// @dev The claim edge is not pending
+error ClaimEdgeNotPending();
+/// @dev The claim edge does not have a length one rival
+error ClaimEdgeNotLengthOneRival(bytes32 claimId);
+/// @dev The claim edge has an invalid level
+error ClaimEdgeInvalidLevel(uint8 argLevel, uint8 claimLevel);
+/// @dev The val is not a power of two
+error NotPowerOfTwo(uint256 val);
+/// @dev The height has an unexpected value
+error InvalidEndHeight(uint256 actualHeight, uint256 expectedHeight);
+/// @dev The prefix proof is empty
+error EmptyPrefixProof();
+/// @dev The edge is not of type SmallStep
+error EdgeTypeNotSmallStep(uint8 level);
+/// @dev The first rival record is empty
+error EmptyFirstRival();
+/// @dev The difference between two heights is less than 2
+error HeightDiffLtTwo(uint256 h1, uint256 h2);
+/// @dev The edge is not pending
+error EdgeNotPending(bytes32 edgeId, EdgeStatus status);
+/// @dev The edge is unrivaled
+error EdgeUnrivaled(bytes32 edgeId);
+/// @dev The edge is not confirmed
+error EdgeNotConfirmed(bytes32 edgeId, EdgeStatus);
+/// @dev The edge level is unexpected
+error EdgeLevelInvalid(bytes32 edgeId1, bytes32 edgeId2, uint8 level1, uint8 level2);
+/// @dev The claim id on the claimingEdge does not match the provided edge id
+error EdgeClaimMismatch(bytes32 edgeId, bytes32 claimingEdgeId);
+/// @dev The origin id is not equal to the mutual id
+error OriginIdMutualIdMismatch(bytes32 mutualId, bytes32 originId);
+/// @dev The total number of blocks is not above the threshold
+error InsufficientConfirmationBlocks(uint256 totalBlocks, uint256 thresholdBlocks);
+/// @dev The edge is not of length one
+error EdgeNotLengthOne(uint256 length);
+/// @dev No origin id supplied when creating an edge
+error EmptyOriginId();
+/// @dev Invalid heights supplied when creating an edge
+error InvalidHeights(uint256 start, uint256 end);
+/// @dev No start root supplied when creating an edge
+error EmptyStartRoot();
+/// @dev No end root supplied when creating an edge
+error EmptyEndRoot();
+/// @dev No staker supplied when creating a layer zero edge
+error EmptyStaker();
+/// @dev No claim id supplied when creating a layer zero edge
+error EmptyClaimId();
+/// @dev Children already set on edge
+error ChildrenAlreadySet(bytes32 edgeId, bytes32 lowerChildId, bytes32 upperChildId);
+/// @dev Edge is not a layer zero edge
+error EdgeNotLayerZero(bytes32 edgeId, address staker, bytes32 claimId);
+/// @dev The edge staker has already been refunded
+error EdgeAlreadyRefunded(bytes32 edgeId);
+/// @dev No assertion chain address supplied
+error EmptyAssertionChain();
+/// @dev No one step proof entry address supplied
+error EmptyOneStepProofEntry();
+/// @dev No challenge period supplied
+error EmptyChallengePeriod();
+/// @dev No stake receiver address supplied
+error EmptyStakeReceiver();
+/// @dev Stake amounts does not match number of levels
+error StakeAmountsMismatch(uint256 stakeLevels, uint256 numLevels);
+/// @dev A rival edge is already confirmed
+error RivalEdgeConfirmed(bytes32 edgeId, bytes32 confirmedRivalId);
+/// @dev Thrown when big step levels is set to 0
+error ZeroBigStepLevels();
+/// @dev Thrown when there are too many big step levels requested
+error BigStepLevelsTooMany(uint8 levels);
+/// @dev Thrown when the level does not correspond to a valid type
+error LevelTooHigh(uint8 level, uint8 numBigStepLevels);
+/// @dev Thrown for unrecognised edge types
+error InvalidEdgeType(EdgeType edgeType);
+/// @dev Thrown when endHistoryRoot not matching the assertion
+error EndHistoryRootMismatch(bytes32 endHistoryRoot, bytes32 assertionEndRoot);
+/// @dev Thrown when the validator whitelist is enabled and the account attempting to create a layer zero edge is not whitelisted
+error NotValidator(address account);
+/// @dev Thrown when an account has already created a rivalling layer zero edge
+error AccountHasMadeLayerZeroRival(address account, bytes32 mutualId);
+/// @dev Thrown when the cached time is already sufficient
+error CachedTimeSufficient(uint256 actual, uint256 expected);
+/// @dev Thrown when the input is an empty array
+error EmptyArray();