@arbitrum/nitro-contracts 3.0.0-alpha.0 → 3.0.0-alpha.2

package/src/challengeV2/IEdgeChallengeManager.sol

@@ -0,0 +1,239 @@
+// 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 stakeToken() external view returns (IERC20);
+
+    function stakeAmounts(
+        uint256
+    ) external view returns (uint256);
+
+    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/ChallengeEdgeLib.sol

@@ -6,63 +6,7 @@ pragma solidity ^0.8.17;
 
 import "./Enums.sol";
 import "./ChallengeErrors.sol";
-
-/// @notice An edge committing to a range of states. These edges will be bisected, slowly
-///         reducing them in length until they reach length one. At that point new edges of a different
-///         level will be added that claim the result of this edge, or a one step proof will be calculated
-///         if the edge level is already of type SmallStep.
-struct ChallengeEdge {
-    /// @notice The origin id is a link from the edge to an edge or assertion at a lower level.
-    ///         Intuitively all edges with the same origin id agree on the information committed to in the origin id
-    ///         For a SmallStep edge the origin id is the 'mutual' id of the length one BigStep edge being claimed by the zero layer ancestors of this edge
-    ///         For a BigStep edge the origin id is the 'mutual' id of the length one Block edge being claimed by the zero layer ancestors of this edge
-    ///         For a Block edge the origin id is the assertion hash of the assertion that is the root of the challenge - all edges in this challenge agree
-    ///         that that assertion hash is valid.
-    ///         The purpose of the origin id is to ensure that only edges that agree on a common start position
-    ///         are being compared against one another.
-    bytes32 originId;
-    /// @notice A root of all the states in the history up to the startHeight
-    bytes32 startHistoryRoot;
-    /// @notice The height of the start history root
-    uint256 startHeight;
-    /// @notice A root of all the states in the history up to the endHeight. Since endHeight > startHeight, the startHistoryRoot must
-    ///         commit to a prefix of the states committed to by the endHistoryRoot
-    bytes32 endHistoryRoot;
-    /// @notice The height of the end history root
-    uint256 endHeight;
-    /// @notice Edges can be bisected into two children. If this edge has been bisected the id of the
-    ///         lower child is populated here, until that time this value is 0. The lower child has startHistoryRoot and startHeight
-    ///         equal to this edge, but endHistoryRoot and endHeight equal to some prefix of the endHistoryRoot of this edge
-    bytes32 lowerChildId;
-    /// @notice Edges can be bisected into two children. If this edge has been bisected the id of the
-    ///         upper child is populated here, until that time this value is 0. The upper child has startHistoryRoot and startHeight
-    ///         equal to some prefix of the endHistoryRoot of this edge, and endHistoryRoot and endHeight equal to this edge
-    bytes32 upperChildId;
-    /// @notice The edge or assertion in the upper level that this edge claims to be true.
-    ///         Only populated on zero layer edges
-    bytes32 claimId;
-    /// @notice The entity that supplied a mini-stake accompanying this edge
-    ///         Only populated on zero layer edges
-    address staker;
-    /// @notice The block number when this edge was created
-    uint64 createdAtBlock;
-    /// @notice The block number at which this edge was confirmed
-    ///         Zero if not confirmed
-    uint64 confirmedAtBlock;
-    /// @notice Current status of this edge. All edges are created Pending, and may be updated to Confirmed
-    ///         Once Confirmed they cannot transition back to Pending
-    EdgeStatus status;
-    /// @notice The level of this edge.
-    ///         Level 0 is type Block
-    ///         Last level (defined by NUM_BIGSTEP_LEVEL + 1) is type SmallStep
-    ///         All levels in between are of type BigStep
-    uint8 level;
-    /// @notice Set to true when the staker has been refunded. Can only be set to true if the status is Confirmed
-    ///         and the staker is non zero.
-    bool refunded;
-    /// @notice TODO
-    uint64 totalTimeUnrivaledCache;
-}
+import "./Structs.sol";
 
 library ChallengeEdgeLib {
     /// @notice Common checks to do when adding an edge

package/src/challengeV2/libraries/EdgeChallengeManagerLib.sol

@@ -8,124 +8,13 @@ import "./UintUtilsLib.sol";
 import "./MerkleTreeAccumulatorLib.sol";
 import "./ChallengeEdgeLib.sol";
 import "../../osp/IOneStepProofEntry.sol";
-import "../../rollup/AssertionState.sol";
 import "../../libraries/Constants.sol";
 import "./ChallengeErrors.sol";
-
-/// @notice An execution state and proof to show that it's valid
-struct AssertionStateData {
-    /// @notice An execution state
-    AssertionState assertionState;
-    /// @notice assertion Hash of the prev assertion
-    bytes32 prevAssertionHash;
-    /// @notice Inbox accumulator of the assertion
-    bytes32 inboxAcc;
-}
-
-/// @notice Data for creating a layer zero edge
-struct CreateEdgeArgs {
-    /// @notice The level of edge to be created. Challenges are decomposed into multiple levels.
-    ///         The first (level 0) being of type Block, followed by n (set by NUM_BIGSTEP_LEVEL) levels of type BigStep, and finally
-    ///         followed by a single level of type SmallStep. Each level is bisected until an edge
-    ///         of length one is reached before proceeding to the next level. The first edge in each level (the layer zero edge)
-    ///         makes a claim about an assertion or assertion in the lower level.
-    ///         Finally in the last level, a SmallStep edge is added that claims a lower level length one BigStep edge, and these
-    ///         SmallStep edges are bisected until they reach length one. A length one small step edge
-    ///         can then be directly executed using a one-step proof.
-    uint8 level;
-    /// @notice The end history root of the edge to be created
-    bytes32 endHistoryRoot;
-    /// @notice The end height of the edge to be created.
-    /// @dev    End height is deterministic for different levels but supplying it here gives the
-    ///         caller a bit of extra security that they are supplying data for the correct level of edge
-    uint256 endHeight;
-    /// @notice The edge, or assertion, that is being claimed correct by the newly created edge.
-    bytes32 claimId;
-    /// @notice Proof that the start history root commits to a prefix of the states that
-    ///         end history root commits to
-    bytes prefixProof;
-    /// @notice Edge type specific data
-    ///         For Block type edges this is the abi encoding of:
-    ///         bytes32[]: Inclusion proof - proof to show that the end state is the last state in the end history root
-    ///         AssertionStateData: the before state of the edge
-    ///         AssertionStateData: the after state of the edge
-    ///         bytes32 predecessorId: id of the prev assertion
-    ///         bytes32 inboxAcc:  the inbox accumulator of the assertion
-    ///         For BigStep and SmallStep edges this is the abi encoding of:
-    ///         bytes32: Start state - first state the edge commits to
-    ///         bytes32: End state - last state the edge commits to
-    ///         bytes32[]: Claim start inclusion proof - proof to show the start state is the first state in the claim edge
-    ///         bytes32[]: Claim end inclusion proof - proof to show the end state is the last state in the claim edge
-    ///         bytes32[]: Inclusion proof - proof to show that the end state is the last state in the end history root
-    bytes proof;
-}
-
-/// @notice Data parsed raw proof data
-struct ProofData {
-    /// @notice The first state being committed to by an edge
-    bytes32 startState;
-    /// @notice The last state being committed to by an edge
-    bytes32 endState;
-    /// @notice A proof that the end state is included in the edge
-    bytes32[] inclusionProof;
-}
-
-/// @notice Stores all edges and their rival status
-struct EdgeStore {
-    /// @notice A mapping of edge id to edges. Edges are never deleted, only created, and potentially confirmed.
-    mapping(bytes32 => ChallengeEdge) edges;
-    /// @notice A mapping of mutualId to edge id. Rivals share the same mutual id, and here we
-    ///         store the edge id of the second edge that was created with the same mutual id - the first rival
-    ///         When only one edge exists for a specific mutual id then a special magic string hash is stored instead
-    ///         of the first rival id, to signify that a single edge does exist with this mutual id
-    mapping(bytes32 => bytes32) firstRivals;
-    /// @notice A mapping of mutualId to the edge id of the confirmed rival with that mutualId
-    /// @dev    Each group of rivals (edges sharing mutual id) can only have at most one confirmed edge
-    mapping(bytes32 => bytes32) confirmedRivals;
-    /// @notice A mapping of account -> mutualId -> bool indicating if the account has created a layer zero edge with a mutual id
-    mapping(address => mapping(bytes32 => bool)) hasMadeLayerZeroRival;
-}
-
-/// @notice Input data to a one step proof
-struct OneStepData {
-    /// @notice The hash of the state that's being executed from
-    bytes32 beforeHash;
-    /// @notice Proof data to accompany the execution context
-    bytes proof;
-}
-
-/// @notice Data about a recently added edge
-struct EdgeAddedData {
-    bytes32 edgeId;
-    bytes32 mutualId;
-    bytes32 originId;
-    bytes32 claimId;
-    uint256 length;
-    uint8 level;
-    bool hasRival;
-    bool isLayerZero;
-}
-
-/// @notice Data about an assertion that is being claimed by an edge
-/// @dev    This extra information that is needed in order to verify that a block edge can be created
-struct AssertionReferenceData {
-    /// @notice The id of the assertion - will be used in a sanity check
-    bytes32 assertionHash;
-    /// @notice The predecessor of the assertion
-    bytes32 predecessorId;
-    /// @notice Is the assertion pending
-    bool isPending;
-    /// @notice Does the assertion have a sibling
-    bool hasSibling;
-    /// @notice The execution state of the predecessor assertion
-    AssertionState startState;
-    /// @notice The execution state of the assertion being claimed
-    AssertionState endState;
-}
-
+import "./Structs.sol";
 /// @title  Core functionality for the Edge Challenge Manager
 /// @notice The edge manager library allows edges to be added and bisected, and keeps track of the amount
 ///         of time an edge remained unrivaled.
+
 library EdgeChallengeManagerLib {
     using ChallengeEdgeLib for ChallengeEdge;
     using GlobalStateLib for GlobalState;

package/src/challengeV2/libraries/Structs.sol

@@ -0,0 +1,176 @@
+// 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 "./Enums.sol";
+import "../../rollup/AssertionState.sol";
+
+/// @notice An execution state and proof to show that it's valid
+struct AssertionStateData {
+    /// @notice An execution state
+    AssertionState assertionState;
+    /// @notice assertion Hash of the prev assertion
+    bytes32 prevAssertionHash;
+    /// @notice Inbox accumulator of the assertion
+    bytes32 inboxAcc;
+}
+
+/// @notice Data for creating a layer zero edge
+struct CreateEdgeArgs {
+    /// @notice The level of edge to be created. Challenges are decomposed into multiple levels.
+    ///         The first (level 0) being of type Block, followed by n (set by NUM_BIGSTEP_LEVEL) levels of type BigStep, and finally
+    ///         followed by a single level of type SmallStep. Each level is bisected until an edge
+    ///         of length one is reached before proceeding to the next level. The first edge in each level (the layer zero edge)
+    ///         makes a claim about an assertion or assertion in the lower level.
+    ///         Finally in the last level, a SmallStep edge is added that claims a lower level length one BigStep edge, and these
+    ///         SmallStep edges are bisected until they reach length one. A length one small step edge
+    ///         can then be directly executed using a one-step proof.
+    uint8 level;
+    /// @notice The end history root of the edge to be created
+    bytes32 endHistoryRoot;
+    /// @notice The end height of the edge to be created.
+    /// @dev    End height is deterministic for different levels but supplying it here gives the
+    ///         caller a bit of extra security that they are supplying data for the correct level of edge
+    uint256 endHeight;
+    /// @notice The edge, or assertion, that is being claimed correct by the newly created edge.
+    bytes32 claimId;
+    /// @notice Proof that the start history root commits to a prefix of the states that
+    ///         end history root commits to
+    bytes prefixProof;
+    /// @notice Edge type specific data
+    ///         For Block type edges this is the abi encoding of:
+    ///         bytes32[]: Inclusion proof - proof to show that the end state is the last state in the end history root
+    ///         AssertionStateData: the before state of the edge
+    ///         AssertionStateData: the after state of the edge
+    ///         bytes32 predecessorId: id of the prev assertion
+    ///         bytes32 inboxAcc:  the inbox accumulator of the assertion
+    ///         For BigStep and SmallStep edges this is the abi encoding of:
+    ///         bytes32: Start state - first state the edge commits to
+    ///         bytes32: End state - last state the edge commits to
+    ///         bytes32[]: Claim start inclusion proof - proof to show the start state is the first state in the claim edge
+    ///         bytes32[]: Claim end inclusion proof - proof to show the end state is the last state in the claim edge
+    ///         bytes32[]: Inclusion proof - proof to show that the end state is the last state in the end history root
+    bytes proof;
+}
+
+/// @notice Data parsed raw proof data
+struct ProofData {
+    /// @notice The first state being committed to by an edge
+    bytes32 startState;
+    /// @notice The last state being committed to by an edge
+    bytes32 endState;
+    /// @notice A proof that the end state is included in the edge
+    bytes32[] inclusionProof;
+}
+
+/// @notice Stores all edges and their rival status
+struct EdgeStore {
+    /// @notice A mapping of edge id to edges. Edges are never deleted, only created, and potentially confirmed.
+    mapping(bytes32 => ChallengeEdge) edges;
+    /// @notice A mapping of mutualId to edge id. Rivals share the same mutual id, and here we
+    ///         store the edge id of the second edge that was created with the same mutual id - the first rival
+    ///         When only one edge exists for a specific mutual id then a special magic string hash is stored instead
+    ///         of the first rival id, to signify that a single edge does exist with this mutual id
+    mapping(bytes32 => bytes32) firstRivals;
+    /// @notice A mapping of mutualId to the edge id of the confirmed rival with that mutualId
+    /// @dev    Each group of rivals (edges sharing mutual id) can only have at most one confirmed edge
+    mapping(bytes32 => bytes32) confirmedRivals;
+    /// @notice A mapping of account -> mutualId -> bool indicating if the account has created a layer zero edge with a mutual id
+    mapping(address => mapping(bytes32 => bool)) hasMadeLayerZeroRival;
+}
+
+/// @notice Input data to a one step proof
+struct OneStepData {
+    /// @notice The hash of the state that's being executed from
+    bytes32 beforeHash;
+    /// @notice Proof data to accompany the execution context
+    bytes proof;
+}
+
+/// @notice Data about a recently added edge
+struct EdgeAddedData {
+    bytes32 edgeId;
+    bytes32 mutualId;
+    bytes32 originId;
+    bytes32 claimId;
+    uint256 length;
+    uint8 level;
+    bool hasRival;
+    bool isLayerZero;
+}
+
+/// @notice Data about an assertion that is being claimed by an edge
+/// @dev    This extra information that is needed in order to verify that a block edge can be created
+struct AssertionReferenceData {
+    /// @notice The id of the assertion - will be used in a sanity check
+    bytes32 assertionHash;
+    /// @notice The predecessor of the assertion
+    bytes32 predecessorId;
+    /// @notice Is the assertion pending
+    bool isPending;
+    /// @notice Does the assertion have a sibling
+    bool hasSibling;
+    /// @notice The execution state of the predecessor assertion
+    AssertionState startState;
+    /// @notice The execution state of the assertion being claimed
+    AssertionState endState;
+}
+
+/// @notice An edge committing to a range of states. These edges will be bisected, slowly
+///         reducing them in length until they reach length one. At that point new edges of a different
+///         level will be added that claim the result of this edge, or a one step proof will be calculated
+///         if the edge level is already of type SmallStep.
+struct ChallengeEdge {
+    /// @notice The origin id is a link from the edge to an edge or assertion at a lower level.
+    ///         Intuitively all edges with the same origin id agree on the information committed to in the origin id
+    ///         For a SmallStep edge the origin id is the 'mutual' id of the length one BigStep edge being claimed by the zero layer ancestors of this edge
+    ///         For a BigStep edge the origin id is the 'mutual' id of the length one Block edge being claimed by the zero layer ancestors of this edge
+    ///         For a Block edge the origin id is the assertion hash of the assertion that is the root of the challenge - all edges in this challenge agree
+    ///         that that assertion hash is valid.
+    ///         The purpose of the origin id is to ensure that only edges that agree on a common start position
+    ///         are being compared against one another.
+    bytes32 originId;
+    /// @notice A root of all the states in the history up to the startHeight
+    bytes32 startHistoryRoot;
+    /// @notice The height of the start history root
+    uint256 startHeight;
+    /// @notice A root of all the states in the history up to the endHeight. Since endHeight > startHeight, the startHistoryRoot must
+    ///         commit to a prefix of the states committed to by the endHistoryRoot
+    bytes32 endHistoryRoot;
+    /// @notice The height of the end history root
+    uint256 endHeight;
+    /// @notice Edges can be bisected into two children. If this edge has been bisected the id of the
+    ///         lower child is populated here, until that time this value is 0. The lower child has startHistoryRoot and startHeight
+    ///         equal to this edge, but endHistoryRoot and endHeight equal to some prefix of the endHistoryRoot of this edge
+    bytes32 lowerChildId;
+    /// @notice Edges can be bisected into two children. If this edge has been bisected the id of the
+    ///         upper child is populated here, until that time this value is 0. The upper child has startHistoryRoot and startHeight
+    ///         equal to some prefix of the endHistoryRoot of this edge, and endHistoryRoot and endHeight equal to this edge
+    bytes32 upperChildId;
+    /// @notice The edge or assertion in the upper level that this edge claims to be true.
+    ///         Only populated on zero layer edges
+    bytes32 claimId;
+    /// @notice The entity that supplied a mini-stake accompanying this edge
+    ///         Only populated on zero layer edges
+    address staker;
+    /// @notice The block number when this edge was created
+    uint64 createdAtBlock;
+    /// @notice The block number at which this edge was confirmed
+    ///         Zero if not confirmed
+    uint64 confirmedAtBlock;
+    /// @notice Current status of this edge. All edges are created Pending, and may be updated to Confirmed
+    ///         Once Confirmed they cannot transition back to Pending
+    EdgeStatus status;
+    /// @notice The level of this edge.
+    ///         Level 0 is type Block
+    ///         Last level (defined by NUM_BIGSTEP_LEVEL + 1) is type SmallStep
+    ///         All levels in between are of type BigStep
+    uint8 level;
+    /// @notice Set to true when the staker has been refunded. Can only be set to true if the status is Confirmed
+    ///         and the staker is non zero.
+    bool refunded;
+    /// @notice TODO
+    uint64 totalTimeUnrivaledCache;
+}

package/src/libraries/CallerChecker.sol

@@ -0,0 +1,18 @@
+// Copyright 2021-2024, Offchain Labs, Inc.
+// For license information, see https://github.com/OffchainLabs/nitro-contracts/blob/main/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+library CallerChecker {
+    /**
+     * @notice A EIP-7702 safe check to ensure the caller is the origin and is codeless
+     * @return bool true if the caller is the origin and is codeless, false otherwise
+     * @dev    If the caller is the origin and is codeless, then msg.data is guaranteed to be same as tx.data
+     *         It also mean the caller would not be able to call a contract multiple times with the same transaction
+     */
+    function isCallerCodelessOrigin() internal view returns (bool) {
+        // solhint-disable-next-line avoid-tx-origin
+        return msg.sender == tx.origin && msg.sender.code.length == 0;
+    }
+}

package/src/libraries/Error.sol

@@ -13,6 +13,9 @@ error HadZeroInit();
 /// @dev Thrown when post upgrade init validation fails
 error BadPostUpgradeInit();
 
+/// @dev Thrown when the caller is not a codeless origin
+error NotCodelessOrigin();
+
 /// @dev Thrown when non owner tries to access an only-owner function
 /// @param sender The msg.sender who is not the owner
 /// @param owner The owner address

package/src/libraries/GasRefundEnabled.sol

@@ -7,6 +7,7 @@ pragma solidity ^0.8.0;
 
 import "./IReader4844.sol";
 import "./IGasRefunder.sol";
+import "../libraries/CallerChecker.sol";
 
 abstract contract GasRefundEnabled {
     uint256 internal immutable gasPerBlob = 2 ** 17;
@@ -24,8 +25,7 @@ abstract contract GasRefundEnabled {
             startGasLeft += calldataWords * 6 + (calldataWords ** 2) / 512;
             // if triggered in a contract call, the spender may be overrefunded by appending dummy data to the call
             // so we check if it is a top level call, which would mean the sender paid calldata as part of tx.input
-            // solhint-disable-next-line avoid-tx-origin
-            if (msg.sender != tx.origin) {
+            if (!CallerChecker.isCallerCodelessOrigin()) {
                 // We can't be sure if this calldata came from the top level tx,
                 // so to be safe we tell the gas refunder there was no calldata.
                 calldataSize = 0;