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

package/src/rollup/ValidatorUtils.sol

@@ -1,243 +1 @@
-// Copyright 2021-2022, 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;
-
-pragma experimental ABIEncoderV2;
-
-import "../rollup/IRollupCore.sol";
-import "../challenge/IChallengeManager.sol";
-import "./IRollupLogic.sol";
-
-import {NO_CHAL_INDEX} from "../libraries/Constants.sol";
-
-contract ValidatorUtils {
-    using NodeLib for Node;
-
-    enum ConfirmType {
-        NONE,
-        VALID,
-        INVALID
-    }
-
-    enum NodeConflictType {
-        NONE,
-        FOUND,
-        INDETERMINATE,
-        INCOMPLETE
-    }
-
-    struct NodeConflict {
-        NodeConflictType ty;
-        uint64 node1;
-        uint64 node2;
-    }
-
-    function findStakerConflict(
-        IRollupCore rollup,
-        address staker1,
-        address staker2,
-        uint256 maxDepth
-    ) external view returns (NodeConflict memory) {
-        uint64 staker1NodeNum = rollup.latestStakedNode(staker1);
-        uint64 staker2NodeNum = rollup.latestStakedNode(staker2);
-        return findNodeConflict(rollup, staker1NodeNum, staker2NodeNum, maxDepth);
-    }
-
-    function checkDecidableNextNode(IRollupUserAbs rollup) external view returns (ConfirmType) {
-        try ValidatorUtils(address(this)).requireConfirmable(rollup) {
-            return ConfirmType.VALID;
-        } catch {}
-
-        try ValidatorUtils(address(this)).requireRejectable(rollup) {
-            return ConfirmType.INVALID;
-        } catch {
-            return ConfirmType.NONE;
-        }
-    }
-
-    function requireRejectable(IRollupCore rollup) external view {
-        IRollupUser(address(rollup)).requireUnresolvedExists();
-        uint64 firstUnresolvedNode = rollup.firstUnresolvedNode();
-        Node memory node = rollup.getNode(firstUnresolvedNode);
-        if (node.prevNum == rollup.latestConfirmed()) {
-            // Verify the block's deadline has passed
-            require(block.number >= node.deadlineBlock, "BEFORE_DEADLINE");
-            rollup.getNode(node.prevNum).requirePastChildConfirmDeadline();
-
-            // Verify that no staker is staked on this node
-            require(
-                node.stakerCount ==
-                    IRollupUser(address(rollup)).countStakedZombies(firstUnresolvedNode),
-                "HAS_STAKERS"
-            );
-        }
-    }
-
-    function requireConfirmable(IRollupUserAbs rollup) external view {
-        rollup.requireUnresolvedExists();
-
-        uint256 stakerCount = rollup.stakerCount();
-        // There is at least one non-zombie staker
-        require(stakerCount > 0, "NO_STAKERS");
-
-        uint64 firstUnresolved = rollup.firstUnresolvedNode();
-        Node memory node = rollup.getNode(firstUnresolved);
-
-        // Verify the block's deadline has passed
-        node.requirePastDeadline();
-
-        // Check that prev is latest confirmed
-        assert(node.prevNum == rollup.latestConfirmed());
-
-        Node memory prevNode = rollup.getNode(node.prevNum);
-        prevNode.requirePastChildConfirmDeadline();
-
-        uint256 zombiesStakedOnOtherChildren = rollup.countZombiesStakedOnChildren(node.prevNum) -
-            rollup.countStakedZombies(firstUnresolved);
-        require(
-            prevNode.childStakerCount == node.stakerCount + zombiesStakedOnOtherChildren,
-            "NOT_ALL_STAKED"
-        );
-    }
-
-    function refundableStakers(IRollupCore rollup) external view returns (address[] memory) {
-        uint256 stakerCount = rollup.stakerCount();
-        address[] memory stakers = new address[](stakerCount);
-        uint256 latestConfirmed = rollup.latestConfirmed();
-        uint256 index = 0;
-        for (uint64 i = 0; i < stakerCount; i++) {
-            address staker = rollup.getStakerAddress(i);
-            uint256 latestStakedNode = rollup.latestStakedNode(staker);
-            if (latestStakedNode <= latestConfirmed && rollup.currentChallenge(staker) == 0) {
-                stakers[index] = staker;
-                index++;
-            }
-        }
-        assembly {
-            mstore(stakers, index)
-        }
-        return stakers;
-    }
-
-    function latestStaked(IRollupCore rollup, address staker)
-        external
-        view
-        returns (uint64, Node memory)
-    {
-        uint64 num = rollup.latestStakedNode(staker);
-        if (num == 0) {
-            num = rollup.latestConfirmed();
-        }
-        Node memory node = rollup.getNode(num);
-        return (num, node);
-    }
-
-    function stakedNodes(IRollupCore rollup, address staker)
-        external
-        view
-        returns (uint64[] memory)
-    {
-        uint64[] memory nodes = new uint64[](100000);
-        uint256 index = 0;
-        for (uint64 i = rollup.latestConfirmed(); i <= rollup.latestNodeCreated(); i++) {
-            if (rollup.nodeHasStaker(i, staker)) {
-                nodes[index] = i;
-                index++;
-            }
-        }
-        // Shrink array down to real size
-        assembly {
-            mstore(nodes, index)
-        }
-        return nodes;
-    }
-
-    function findNodeConflict(
-        IRollupCore rollup,
-        uint64 node1,
-        uint64 node2,
-        uint256 maxDepth
-    ) public view returns (NodeConflict memory) {
-        uint64 firstUnresolvedNode = rollup.firstUnresolvedNode();
-        uint64 node1Prev = rollup.getNode(node1).prevNum;
-        uint64 node2Prev = rollup.getNode(node2).prevNum;
-
-        for (uint256 i = 0; i < maxDepth; i++) {
-            if (node1 == node2) {
-                return NodeConflict(NodeConflictType.NONE, node1, node2);
-            }
-            if (node1Prev == node2Prev) {
-                return NodeConflict(NodeConflictType.FOUND, node1, node2);
-            }
-            if (node1Prev < firstUnresolvedNode && node2Prev < firstUnresolvedNode) {
-                return NodeConflict(NodeConflictType.INDETERMINATE, 0, 0);
-            }
-            if (node1Prev < node2Prev) {
-                node2 = node2Prev;
-                node2Prev = rollup.getNode(node2).prevNum;
-            } else {
-                node1 = node1Prev;
-                node1Prev = rollup.getNode(node1).prevNum;
-            }
-        }
-        return NodeConflict(NodeConflictType.INCOMPLETE, 0, 0);
-    }
-
-    function getStakers(
-        IRollupCore rollup,
-        uint64 startIndex,
-        uint64 max
-    ) public view returns (address[] memory, bool hasMore) {
-        uint256 maxStakers = rollup.stakerCount();
-        if (startIndex + max <= maxStakers) {
-            maxStakers = startIndex + max;
-            hasMore = true;
-        }
-
-        address[] memory stakers = new address[](maxStakers);
-        for (uint64 i = 0; i < maxStakers; i++) {
-            stakers[i] = rollup.getStakerAddress(startIndex + i);
-        }
-        return (stakers, hasMore);
-    }
-
-    function timedOutChallenges(
-        IRollupCore rollup,
-        uint64 startIndex,
-        uint64 max
-    ) external view returns (uint64[] memory, bool hasMore) {
-        (address[] memory stakers, bool hasMoreStakers) = getStakers(rollup, startIndex, max);
-        uint64[] memory challenges = new uint64[](stakers.length);
-        uint256 index = 0;
-        IChallengeManager challengeManager = rollup.challengeManager();
-        for (uint256 i = 0; i < stakers.length; i++) {
-            address staker = stakers[i];
-            uint64 challengeIndex = rollup.currentChallenge(staker);
-            if (
-                challengeIndex != NO_CHAL_INDEX &&
-                challengeManager.isTimedOut(challengeIndex) &&
-                challengeManager.currentResponder(challengeIndex) == staker
-            ) {
-                challenges[index++] = challengeIndex;
-            }
-        }
-        // Shrink array down to real size
-        assembly {
-            mstore(challenges, index)
-        }
-        return (challenges, hasMoreStakers);
-    }
-
-    // Worst case runtime of O(depth), as it terminates if it switches paths.
-    function areUnresolvedNodesLinear(IRollupCore rollup) external view returns (bool) {
-        uint256 end = rollup.latestNodeCreated();
-        for (uint64 i = rollup.firstUnresolvedNode(); i <= end; i++) {
-            if (i > 0 && rollup.getNode(i).prevNum != i - 1) {
-                return false;
-            }
-        }
-        return true;
-    }
-}

package/src/rollup/ValidatorWallet.sol

@@ -4,7 +4,6 @@
 
 pragma solidity ^0.8.0;
 
-import "../challenge/IChallengeManager.sol";
 import "../libraries/DelegateCallAware.sol";
 import "../libraries/IGasRefunder.sol";
 import "../libraries/GasRefundEnabled.sol";
@@ -33,20 +32,22 @@ contract ValidatorWallet is OwnableUpgradeable, DelegateCallAware, GasRefundEnab
     mapping(address => bool) public allowedExecutorDestinations;
 
     modifier onlyExecutorOrOwner() {
-        if (!executors[_msgSender()] && owner() != _msgSender())
+        if (!executors[_msgSender()] && owner() != _msgSender()) {
             revert NotExecutorOrOwner(_msgSender());
+        }
         _;
     }
 
     event ExecutorUpdated(address indexed executor, bool isExecutor);
 
     /// @dev updates the executor addresses
-    function setExecutor(address[] calldata newExecutors, bool[] calldata isExecutor)
-        external
-        onlyOwner
-    {
-        if (newExecutors.length != isExecutor.length)
+    function setExecutor(
+        address[] calldata newExecutors,
+        bool[] calldata isExecutor
+    ) external onlyOwner {
+        if (newExecutors.length != isExecutor.length) {
             revert BadArrayLength(newExecutors.length, isExecutor.length);
+        }
         unchecked {
             for (uint64 i = 0; i < newExecutors.length; ++i) {
                 executors[newExecutors[i]] = isExecutor[i];
@@ -77,12 +78,13 @@ contract ValidatorWallet is OwnableUpgradeable, DelegateCallAware, GasRefundEnab
     event AllowedExecutorDestinationsUpdated(address indexed destination, bool isSet);
 
     /// @notice updates the destination addresses which executors are allowed to call
-    function setAllowedExecutorDestinations(address[] calldata destinations, bool[] calldata isSet)
-        external
-        onlyOwner
-    {
-        if (destinations.length != isSet.length)
+    function setAllowedExecutorDestinations(
+        address[] calldata destinations,
+        bool[] calldata isSet
+    ) external onlyOwner {
+        if (destinations.length != isSet.length) {
             revert BadArrayLength(destinations.length, isSet.length);
+        }
         unchecked {
             for (uint256 i = 0; i < destinations.length; ++i) {
                 allowedExecutorDestinations[destinations[i]] = isSet[i];
@@ -92,9 +94,12 @@ contract ValidatorWallet is OwnableUpgradeable, DelegateCallAware, GasRefundEnab
     }
 
     /// @dev reverts if the current function can't be called
-    function validateExecuteTransaction(address destination) public view {
-        if (!allowedExecutorDestinations[destination] && owner() != _msgSender())
+    function validateExecuteTransaction(
+        address destination
+    ) public view {
+        if (!allowedExecutorDestinations[destination] && owner() != _msgSender()) {
             revert OnlyOwnerDestination(owner(), _msgSender(), destination);
+        }
     }
 
     function executeTransactions(
@@ -120,7 +125,7 @@ contract ValidatorWallet is OwnableUpgradeable, DelegateCallAware, GasRefundEnab
             validateExecuteTransaction(destination[i]);
             // We use a low level call here to allow for contract and non-contract calls
             // solhint-disable-next-line avoid-low-level-calls
-            (bool success, ) = address(destination[i]).call{value: amount[i]}(data[i]);
+            (bool success,) = address(destination[i]).call{value: amount[i]}(data[i]);
             if (!success) {
                 assembly {
                     let ptr := mload(0x40)
@@ -150,7 +155,7 @@ contract ValidatorWallet is OwnableUpgradeable, DelegateCallAware, GasRefundEnab
         validateExecuteTransaction(destination);
         // We use a low level call here to allow for contract and non-contract calls
         // solhint-disable-next-line avoid-low-level-calls
-        (bool success, ) = destination.call{value: amount}(data);
+        (bool success,) = destination.call{value: amount}(data);
         if (!success) {
             assembly {
                 let ptr := mload(0x40)
@@ -161,33 +166,12 @@ contract ValidatorWallet is OwnableUpgradeable, DelegateCallAware, GasRefundEnab
         }
     }
 
-    function timeoutChallenges(IChallengeManager manager, uint64[] calldata challenges) external {
-        timeoutChallengesWithGasRefunder(IGasRefunder(address(0)), manager, challenges);
-    }
-
-    function timeoutChallengesWithGasRefunder(
-        IGasRefunder gasRefunder,
-        IChallengeManager manager,
-        uint64[] calldata challenges
-    ) public onlyExecutorOrOwner refundsGas(gasRefunder, IReader4844(address(0))) {
-        uint256 challengesCount = challenges.length;
-        for (uint256 i = 0; i < challengesCount; i++) {
-            try manager.timeout(challenges[i]) {} catch (bytes memory error) {
-                if (error.length == 0) {
-                    // Assume out of gas
-                    // We need to revert here so gas estimation works
-                    require(false, "GAS");
-                }
-            }
-        }
-    }
-
     receive() external payable {}
 
     /// @dev allows the owner to withdraw eth held by this contract
     function withdrawEth(uint256 amount, address destination) external onlyOwner {
         // solhint-disable-next-line avoid-low-level-calls
-        (bool success, ) = destination.call{value: amount}("");
+        (bool success,) = destination.call{value: amount}("");
         if (!success) revert WithdrawEthFail(destination);
     }
 }

package/src/rollup/ValidatorWalletCreator.sol

@@ -25,21 +25,21 @@ contract ValidatorWalletCreator is Ownable {
         template = address(new ValidatorWallet());
     }
 
-    function setTemplate(address _template) external onlyOwner {
+    function setTemplate(
+        address _template
+    ) external onlyOwner {
         template = _template;
         emit TemplateUpdated();
     }
 
-    function createWallet(address[] calldata initialExecutorAllowedDests)
-        external
-        returns (address)
-    {
+    function createWallet(
+        address[] calldata initialExecutorAllowedDests
+    ) external returns (address) {
         address _executor = msg.sender;
         address _owner = msg.sender;
         ProxyAdmin admin = new ProxyAdmin();
-        address proxy = address(
-            new TransparentUpgradeableProxy(address(template), address(admin), "")
-        );
+        address proxy =
+            address(new TransparentUpgradeableProxy(address(template), address(admin), ""));
         admin.transferOwnership(_owner);
         ValidatorWallet(payable(proxy)).initialize(_executor, _owner, initialExecutorAllowedDests);
         emit WalletCreated(proxy, _executor, _owner, address(admin));

package/src/state/Deserialize.sol

@@ -16,21 +16,19 @@ import "./Module.sol";
 import "./GlobalState.sol";
 
 library Deserialize {
-    function u8(bytes calldata proof, uint256 startOffset)
-        internal
-        pure
-        returns (uint8 ret, uint256 offset)
-    {
+    function u8(
+        bytes calldata proof,
+        uint256 startOffset
+    ) internal pure returns (uint8 ret, uint256 offset) {
         offset = startOffset;
         ret = uint8(proof[offset]);
         offset++;
     }
 
-    function u16(bytes calldata proof, uint256 startOffset)
-        internal
-        pure
-        returns (uint16 ret, uint256 offset)
-    {
+    function u16(
+        bytes calldata proof,
+        uint256 startOffset
+    ) internal pure returns (uint16 ret, uint256 offset) {
         offset = startOffset;
         for (uint256 i = 0; i < 16 / 8; i++) {
             ret <<= 8;
@@ -39,11 +37,10 @@ library Deserialize {
         }
     }
 
-    function u32(bytes calldata proof, uint256 startOffset)
-        internal
-        pure
-        returns (uint32 ret, uint256 offset)
-    {
+    function u32(
+        bytes calldata proof,
+        uint256 startOffset
+    ) internal pure returns (uint32 ret, uint256 offset) {
         offset = startOffset;
         for (uint256 i = 0; i < 32 / 8; i++) {
             ret <<= 8;
@@ -52,11 +49,10 @@ library Deserialize {
         }
     }
 
-    function u64(bytes calldata proof, uint256 startOffset)
-        internal
-        pure
-        returns (uint64 ret, uint256 offset)
-    {
+    function u64(
+        bytes calldata proof,
+        uint256 startOffset
+    ) internal pure returns (uint64 ret, uint256 offset) {
         offset = startOffset;
         for (uint256 i = 0; i < 64 / 8; i++) {
             ret <<= 8;
@@ -65,11 +61,10 @@ library Deserialize {
         }
     }
 
-    function u256(bytes calldata proof, uint256 startOffset)
-        internal
-        pure
-        returns (uint256 ret, uint256 offset)
-    {
+    function u256(
+        bytes calldata proof,
+        uint256 startOffset
+    ) internal pure returns (uint256 ret, uint256 offset) {
         offset = startOffset;
         for (uint256 i = 0; i < 256 / 8; i++) {
             ret <<= 8;
@@ -78,32 +73,29 @@ library Deserialize {
         }
     }
 
-    function b32(bytes calldata proof, uint256 startOffset)
-        internal
-        pure
-        returns (bytes32 ret, uint256 offset)
-    {
+    function b32(
+        bytes calldata proof,
+        uint256 startOffset
+    ) internal pure returns (bytes32 ret, uint256 offset) {
         offset = startOffset;
         uint256 retInt;
         (retInt, offset) = u256(proof, offset);
         ret = bytes32(retInt);
     }
 
-    function boolean(bytes calldata proof, uint256 startOffset)
-        internal
-        pure
-        returns (bool ret, uint256 offset)
-    {
+    function boolean(
+        bytes calldata proof,
+        uint256 startOffset
+    ) internal pure returns (bool ret, uint256 offset) {
         offset = startOffset;
         ret = uint8(proof[offset]) != 0;
         offset++;
     }
 
-    function value(bytes calldata proof, uint256 startOffset)
-        internal
-        pure
-        returns (Value memory val, uint256 offset)
-    {
+    function value(
+        bytes calldata proof,
+        uint256 startOffset
+    ) internal pure returns (Value memory val, uint256 offset) {
         offset = startOffset;
         uint8 typeInt = uint8(proof[offset]);
         offset++;
@@ -113,11 +105,10 @@ library Deserialize {
         val = Value({valueType: ValueType(typeInt), contents: contents});
     }
 
-    function valueStack(bytes calldata proof, uint256 startOffset)
-        internal
-        pure
-        returns (ValueStack memory stack, uint256 offset)
-    {
+    function valueStack(
+        bytes calldata proof,
+        uint256 startOffset
+    ) internal pure returns (ValueStack memory stack, uint256 offset) {
         offset = startOffset;
         bytes32 remainingHash;
         (remainingHash, offset) = b32(proof, offset);
@@ -130,27 +121,23 @@ library Deserialize {
         stack = ValueStack({proved: ValueArray(proved), remainingHash: remainingHash});
     }
 
-    function multiStack(bytes calldata proof, uint256 startOffset)
-        internal
-        pure
-        returns (MultiStack memory multistack, uint256 offset)
-    {
+    function multiStack(
+        bytes calldata proof,
+        uint256 startOffset
+    ) internal pure returns (MultiStack memory multistack, uint256 offset) {
         offset = startOffset;
         bytes32 inactiveStackHash;
         (inactiveStackHash, offset) = b32(proof, offset);
         bytes32 remainingHash;
         (remainingHash, offset) = b32(proof, offset);
-        multistack = MultiStack({
-            inactiveStackHash: inactiveStackHash,
-            remainingHash: remainingHash
-        });
+        multistack =
+            MultiStack({inactiveStackHash: inactiveStackHash, remainingHash: remainingHash});
     }
 
-    function instructions(bytes calldata proof, uint256 startOffset)
-        internal
-        pure
-        returns (Instruction[] memory code, uint256 offset)
-    {
+    function instructions(
+        bytes calldata proof,
+        uint256 startOffset
+    ) internal pure returns (Instruction[] memory code, uint256 offset) {
         offset = startOffset;
         uint8 count;
         (count, offset) = u8(proof, offset);
@@ -165,11 +152,10 @@ library Deserialize {
         }
     }
 
-    function stackFrame(bytes calldata proof, uint256 startOffset)
-        internal
-        pure
-        returns (StackFrame memory window, uint256 offset)
-    {
+    function stackFrame(
+        bytes calldata proof,
+        uint256 startOffset
+    ) internal pure returns (StackFrame memory window, uint256 offset) {
         offset = startOffset;
         Value memory returnPc;
         bytes32 localsMerkleRoot;
@@ -187,11 +173,10 @@ library Deserialize {
         });
     }
 
-    function stackFrameWindow(bytes calldata proof, uint256 startOffset)
-        internal
-        pure
-        returns (StackFrameWindow memory window, uint256 offset)
-    {
+    function stackFrameWindow(
+        bytes calldata proof,
+        uint256 startOffset
+    ) internal pure returns (StackFrameWindow memory window, uint256 offset) {
         offset = startOffset;
         bytes32 remainingHash;
         (remainingHash, offset) = b32(proof, offset);
@@ -207,11 +192,10 @@ library Deserialize {
         window = StackFrameWindow({proved: proved, remainingHash: remainingHash});
     }
 
-    function moduleMemory(bytes calldata proof, uint256 startOffset)
-        internal
-        pure
-        returns (ModuleMemory memory mem, uint256 offset)
-    {
+    function moduleMemory(
+        bytes calldata proof,
+        uint256 startOffset
+    ) internal pure returns (ModuleMemory memory mem, uint256 offset) {
         offset = startOffset;
         uint64 size;
         uint64 maxSize;
@@ -222,11 +206,10 @@ library Deserialize {
         mem = ModuleMemory({size: size, maxSize: maxSize, merkleRoot: root});
     }
 
-    function module(bytes calldata proof, uint256 startOffset)
-        internal
-        pure
-        returns (Module memory mod, uint256 offset)
-    {
+    function module(
+        bytes calldata proof,
+        uint256 startOffset
+    ) internal pure returns (Module memory mod, uint256 offset) {
         offset = startOffset;
         bytes32 globalsMerkleRoot;
         ModuleMemory memory mem;
@@ -250,11 +233,10 @@ library Deserialize {
         });
     }
 
-    function globalState(bytes calldata proof, uint256 startOffset)
-        internal
-        pure
-        returns (GlobalState memory state, uint256 offset)
-    {
+    function globalState(
+        bytes calldata proof,
+        uint256 startOffset
+    ) internal pure returns (GlobalState memory state, uint256 offset) {
         offset = startOffset;
 
         // using constant ints for array size requires newer solidity
@@ -270,11 +252,10 @@ library Deserialize {
         state = GlobalState({bytes32Vals: bytes32Vals, u64Vals: u64Vals});
     }
 
-    function machine(bytes calldata proof, uint256 startOffset)
-        internal
-        pure
-        returns (Machine memory mach, uint256 offset)
-    {
+    function machine(
+        bytes calldata proof,
+        uint256 startOffset
+    ) internal pure returns (Machine memory mach, uint256 offset) {
         offset = startOffset;
         {
             MachineStatus status;
@@ -287,8 +268,6 @@ library Deserialize {
                     status = MachineStatus.FINISHED;
                 } else if (statusU8 == 2) {
                     status = MachineStatus.ERRORED;
-                } else if (statusU8 == 3) {
-                    status = MachineStatus.TOO_FAR;
                 } else {
                     revert("UNKNOWN_MACH_STATUS");
                 }
@@ -326,11 +305,10 @@ library Deserialize {
         (mach.modulesRoot, offset) = b32(proof, offset);
     }
 
-    function merkleProof(bytes calldata proof, uint256 startOffset)
-        internal
-        pure
-        returns (MerkleProof memory merkle, uint256 offset)
-    {
+    function merkleProof(
+        bytes calldata proof,
+        uint256 startOffset
+    ) internal pure returns (MerkleProof memory merkle, uint256 offset) {
         offset = startOffset;
         uint8 length;
         (length, offset) = u8(proof, offset);