@arbitrum/nitro-contracts 1.0.0-beta.1

package/src/rollup/ValidatorUtils.sol

@@ -0,0 +1,243 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+pragma experimental ABIEncoderV2;
+
+import "../rollup/IRollupCore.sol";
+import "../rollup/IRollupLogic.sol";
+import "../challenge/IChallengeManager.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

@@ -0,0 +1,76 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "./IRollupLogic.sol";
+import "../challenge/IChallengeManager.sol";
+import "../libraries/DelegateCallAware.sol";
+import "@openzeppelin/contracts/utils/Address.sol";
+import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+
+contract ValidatorWallet is OwnableUpgradeable, DelegateCallAware {
+    using Address for address;
+
+    function initialize() external initializer onlyDelegated {
+        __Ownable_init();
+    }
+
+    function executeTransactions(
+        bytes[] calldata data,
+        address[] calldata destination,
+        uint256[] calldata amount
+    ) external payable onlyOwner {
+        uint256 numTxes = data.length;
+        for (uint256 i = 0; i < numTxes; i++) {
+            if (data[i].length > 0) require(destination[i].isContract(), "NO_CODE_AT_ADDR");
+            // 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]);
+            if (!success) {
+                assembly {
+                    let ptr := mload(0x40)
+                    let size := returndatasize()
+                    returndatacopy(ptr, 0, size)
+                    revert(ptr, size)
+                }
+            }
+        }
+    }
+
+    function executeTransaction(
+        bytes calldata data,
+        address destination,
+        uint256 amount
+    ) external payable onlyOwner {
+        if (data.length > 0) require(destination.isContract(), "NO_CODE_AT_ADDR");
+        // 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);
+        if (!success) {
+            assembly {
+                let ptr := mload(0x40)
+                let size := returndatasize()
+                returndatacopy(ptr, 0, size)
+                revert(ptr, size)
+            }
+        }
+    }
+
+    function timeoutChallenges(IChallengeManager manager, uint64[] calldata challenges)
+        external
+        onlyOwner
+    {
+        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");
+                }
+            }
+        }
+    }
+}

package/src/rollup/ValidatorWalletCreator.sol

@@ -0,0 +1,43 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
+import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+import "./ValidatorWallet.sol";
+
+contract ValidatorWalletCreator is Ownable {
+    event WalletCreated(
+        address indexed walletAddress,
+        address indexed userAddress,
+        address adminProxy
+    );
+    event TemplateUpdated();
+
+    address public template;
+
+    constructor() Ownable() {
+        template = address(new ValidatorWallet());
+    }
+
+    function setTemplate(address _template) external onlyOwner {
+        template = _template;
+        emit TemplateUpdated();
+    }
+
+    function createWallet() external returns (address) {
+        ProxyAdmin admin = new ProxyAdmin();
+        address proxy = address(
+            new TransparentUpgradeableProxy(address(template), address(admin), "")
+        );
+        admin.transferOwnership(msg.sender);
+        ValidatorWallet(proxy).initialize();
+        ValidatorWallet(proxy).transferOwnership(msg.sender);
+        emit WalletCreated(proxy, msg.sender, address(admin));
+        return proxy;
+    }
+}

package/src/state/Deserialize.sol

@@ -0,0 +1,321 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "./Value.sol";
+import "./ValueStack.sol";
+import "./PcStack.sol";
+import "./Machine.sol";
+import "./Instructions.sol";
+import "./StackFrame.sol";
+import "./MerkleProof.sol";
+import "./ModuleMemory.sol";
+import "./Module.sol";
+import "./GlobalState.sol";
+
+library Deserialize {
+    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)
+    {
+        offset = startOffset;
+        for (uint256 i = 0; i < 16 / 8; i++) {
+            ret <<= 8;
+            ret |= uint8(proof[offset]);
+            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;
+            ret |= uint8(proof[offset]);
+            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;
+            ret |= uint8(proof[offset]);
+            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;
+            ret |= uint8(proof[offset]);
+            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 value(bytes calldata proof, uint256 startOffset)
+        internal
+        pure
+        returns (Value memory val, uint256 offset)
+    {
+        offset = startOffset;
+        uint8 typeInt = uint8(proof[offset]);
+        offset++;
+        require(typeInt <= uint8(ValueLib.maxValueType()), "BAD_VALUE_TYPE");
+        uint256 contents;
+        (contents, offset) = u256(proof, offset);
+        val = Value({valueType: ValueType(typeInt), contents: contents});
+    }
+
+    function valueStack(bytes calldata proof, uint256 startOffset)
+        internal
+        pure
+        returns (ValueStack memory stack, uint256 offset)
+    {
+        offset = startOffset;
+        bytes32 remainingHash;
+        (remainingHash, offset) = b32(proof, offset);
+        uint256 provedLength;
+        (provedLength, offset) = u256(proof, offset);
+        Value[] memory proved = new Value[](provedLength);
+        for (uint256 i = 0; i < proved.length; i++) {
+            (proved[i], offset) = value(proof, offset);
+        }
+        stack = ValueStack({proved: ValueArray(proved), remainingHash: remainingHash});
+    }
+
+    function pcStack(bytes calldata proof, uint256 startOffset)
+        internal
+        pure
+        returns (PcStack memory stack, uint256 offset)
+    {
+        offset = startOffset;
+        bytes32 remainingHash;
+        (remainingHash, offset) = b32(proof, offset);
+        uint256 provedLength;
+        (provedLength, offset) = u256(proof, offset);
+        uint32[] memory proved = new uint32[](provedLength);
+        for (uint256 i = 0; i < proved.length; i++) {
+            (proved[i], offset) = u32(proof, offset);
+        }
+        stack = PcStack({proved: PcArray(proved), remainingHash: remainingHash});
+    }
+
+    function instruction(bytes calldata proof, uint256 startOffset)
+        internal
+        pure
+        returns (Instruction memory inst, uint256 offset)
+    {
+        offset = startOffset;
+        uint16 opcode;
+        uint256 data;
+        (opcode, offset) = u16(proof, offset);
+        (data, offset) = u256(proof, offset);
+        inst = Instruction({opcode: opcode, argumentData: data});
+    }
+
+    function stackFrame(bytes calldata proof, uint256 startOffset)
+        internal
+        pure
+        returns (StackFrame memory window, uint256 offset)
+    {
+        offset = startOffset;
+        Value memory returnPc;
+        bytes32 localsMerkleRoot;
+        uint32 callerModule;
+        uint32 callerModuleInternals;
+        (returnPc, offset) = value(proof, offset);
+        (localsMerkleRoot, offset) = b32(proof, offset);
+        (callerModule, offset) = u32(proof, offset);
+        (callerModuleInternals, offset) = u32(proof, offset);
+        window = StackFrame({
+            returnPc: returnPc,
+            localsMerkleRoot: localsMerkleRoot,
+            callerModule: callerModule,
+            callerModuleInternals: callerModuleInternals
+        });
+    }
+
+    function stackFrameWindow(bytes calldata proof, uint256 startOffset)
+        internal
+        pure
+        returns (StackFrameWindow memory window, uint256 offset)
+    {
+        offset = startOffset;
+        bytes32 remainingHash;
+        (remainingHash, offset) = b32(proof, offset);
+        StackFrame[] memory proved;
+        if (proof[offset] != 0) {
+            offset++;
+            proved = new StackFrame[](1);
+            (proved[0], offset) = stackFrame(proof, offset);
+        } else {
+            offset++;
+            proved = new StackFrame[](0);
+        }
+        window = StackFrameWindow({proved: proved, remainingHash: remainingHash});
+    }
+
+    function moduleMemory(bytes calldata proof, uint256 startOffset)
+        internal
+        pure
+        returns (ModuleMemory memory mem, uint256 offset)
+    {
+        offset = startOffset;
+        uint64 size;
+        bytes32 root;
+        (size, offset) = u64(proof, offset);
+        (root, offset) = b32(proof, offset);
+        mem = ModuleMemory({size: size, merkleRoot: root});
+    }
+
+    function module(bytes calldata proof, uint256 startOffset)
+        internal
+        pure
+        returns (Module memory mod, uint256 offset)
+    {
+        offset = startOffset;
+        bytes32 globalsMerkleRoot;
+        ModuleMemory memory mem;
+        bytes32 tablesMerkleRoot;
+        bytes32 functionsMerkleRoot;
+        uint32 internalsOffset;
+        (globalsMerkleRoot, offset) = b32(proof, offset);
+        (mem, offset) = moduleMemory(proof, offset);
+        (tablesMerkleRoot, offset) = b32(proof, offset);
+        (functionsMerkleRoot, offset) = b32(proof, offset);
+        (internalsOffset, offset) = u32(proof, offset);
+        mod = Module({
+            globalsMerkleRoot: globalsMerkleRoot,
+            moduleMemory: mem,
+            tablesMerkleRoot: tablesMerkleRoot,
+            functionsMerkleRoot: functionsMerkleRoot,
+            internalsOffset: internalsOffset
+        });
+    }
+
+    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
+        bytes32[2] memory bytes32Vals;
+        uint64[2] memory u64Vals;
+
+        for (uint8 i = 0; i < GlobalStateLib.BYTES32_VALS_NUM; i++) {
+            (bytes32Vals[i], offset) = b32(proof, offset);
+        }
+        for (uint8 i = 0; i < GlobalStateLib.U64_VALS_NUM; i++) {
+            (u64Vals[i], offset) = u64(proof, offset);
+        }
+        state = GlobalState({bytes32Vals: bytes32Vals, u64Vals: u64Vals});
+    }
+
+    function machine(bytes calldata proof, uint256 startOffset)
+        internal
+        pure
+        returns (Machine memory mach, uint256 offset)
+    {
+        offset = startOffset;
+        MachineStatus status;
+        {
+            uint8 statusU8;
+            (statusU8, offset) = u8(proof, offset);
+            if (statusU8 == 0) {
+                status = MachineStatus.RUNNING;
+            } else if (statusU8 == 1) {
+                status = MachineStatus.FINISHED;
+            } else if (statusU8 == 2) {
+                status = MachineStatus.ERRORED;
+            } else if (statusU8 == 3) {
+                status = MachineStatus.TOO_FAR;
+            } else {
+                revert("UNKNOWN_MACH_STATUS");
+            }
+        }
+        ValueStack memory values;
+        ValueStack memory internalStack;
+        PcStack memory blocks;
+        bytes32 globalStateHash;
+        uint32 moduleIdx;
+        uint32 functionIdx;
+        uint32 functionPc;
+        StackFrameWindow memory frameStack;
+        bytes32 modulesRoot;
+        (values, offset) = valueStack(proof, offset);
+        (internalStack, offset) = valueStack(proof, offset);
+        (blocks, offset) = pcStack(proof, offset);
+        (frameStack, offset) = stackFrameWindow(proof, offset);
+        (globalStateHash, offset) = b32(proof, offset);
+        (moduleIdx, offset) = u32(proof, offset);
+        (functionIdx, offset) = u32(proof, offset);
+        (functionPc, offset) = u32(proof, offset);
+        (modulesRoot, offset) = b32(proof, offset);
+        mach = Machine({
+            status: status,
+            valueStack: values,
+            internalStack: internalStack,
+            blockStack: blocks,
+            frameStack: frameStack,
+            globalStateHash: globalStateHash,
+            moduleIdx: moduleIdx,
+            functionIdx: functionIdx,
+            functionPc: functionPc,
+            modulesRoot: modulesRoot
+        });
+    }
+
+    function merkleProof(bytes calldata proof, uint256 startOffset)
+        internal
+        pure
+        returns (MerkleProof memory merkle, uint256 offset)
+    {
+        offset = startOffset;
+        uint8 length;
+        (length, offset) = u8(proof, offset);
+        bytes32[] memory counterparts = new bytes32[](length);
+        for (uint8 i = 0; i < length; i++) {
+            (counterparts[i], offset) = b32(proof, offset);
+        }
+        merkle = MerkleProof(counterparts);
+    }
+}