@arbitrum/nitro-contracts 1.0.0-beta.1

package/src/rollup/IRollupLogic.sol

@@ -0,0 +1,183 @@
+// 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 "./RollupLib.sol";
+import "./IRollupCore.sol";
+import "../bridge/ISequencerInbox.sol";
+import "../bridge/IOutbox.sol";
+
+interface IRollupUserAbs is IRollupCore {
+    /// @dev the user logic just validated configuration and shouldn't write to state during init
+    /// this allows the admin logic to ensure consistency on parameters.
+    function initialize(address stakeToken) external view;
+
+    function isERC20Enabled() external view returns (bool);
+
+    function returnOldDeposit(address stakerAddress) external;
+
+    function requireUnresolved(uint256 nodeNum) external view;
+
+    function requireUnresolvedExists() external view;
+
+    function countStakedZombies(uint64 nodeNum) external view returns (uint256);
+
+    function countZombiesStakedOnChildren(uint64 nodeNum) external view returns (uint256);
+}
+
+interface IRollupUser is IRollupUserAbs {
+    function newStakeOnExistingNode(uint64 nodeNum, bytes32 nodeHash) external payable;
+
+    function newStakeOnNewNode(
+        RollupLib.Assertion calldata assertion,
+        bytes32 expectedNodeHash,
+        uint256 prevNodeInboxMaxCount
+    ) external payable;
+}
+
+interface IRollupUserERC20 is IRollupUserAbs {
+    function newStakeOnExistingNode(
+        uint256 tokenAmount,
+        uint64 nodeNum,
+        bytes32 nodeHash
+    ) external;
+
+    function newStakeOnNewNode(
+        uint256 tokenAmount,
+        RollupLib.Assertion calldata assertion,
+        bytes32 expectedNodeHash,
+        uint256 prevNodeInboxMaxCount
+    ) external;
+}
+
+interface IRollupAdmin {
+    event OwnerFunctionCalled(uint256 indexed id);
+
+    function initialize(Config calldata config, ContractDependencies calldata connectedContracts)
+        external;
+
+    /**
+     * @notice Add a contract authorized to put messages into this rollup's inbox
+     * @param _outbox Outbox contract to add
+     */
+    function setOutbox(IOutbox _outbox) external;
+
+    /**
+     * @notice Disable an old outbox from interacting with the bridge
+     * @param _outbox Outbox contract to remove
+     */
+    function removeOldOutbox(address _outbox) external;
+
+    /**
+     * @notice Enable or disable an inbox contract
+     * @param _inbox Inbox contract to add or remove
+     * @param _enabled New status of inbox
+     */
+    function setInbox(address _inbox, bool _enabled) external;
+
+    /**
+     * @notice Pause interaction with the rollup contract
+     */
+    function pause() external;
+
+    /**
+     * @notice Resume interaction with the rollup contract
+     */
+    function resume() external;
+
+    /**
+     * @notice Set the addresses of the validator whitelist
+     * @dev It is expected that both arrays are same length, and validator at
+     * position i corresponds to the value at position i
+     * @param _validator addresses to set in the whitelist
+     * @param _val value to set in the whitelist for corresponding address
+     */
+    function setValidator(address[] memory _validator, bool[] memory _val) external;
+
+    /**
+     * @notice Set a new owner address for the rollup proxy
+     * @param newOwner address of new rollup owner
+     */
+    function setOwner(address newOwner) external;
+
+    /**
+     * @notice Set minimum assertion period for the rollup
+     * @param newPeriod new minimum period for assertions
+     */
+    function setMinimumAssertionPeriod(uint256 newPeriod) external;
+
+    /**
+     * @notice Set number of blocks until a node is considered confirmed
+     * @param newConfirmPeriod new number of blocks until a node is confirmed
+     */
+    function setConfirmPeriodBlocks(uint64 newConfirmPeriod) external;
+
+    /**
+     * @notice Set number of extra blocks after a challenge
+     * @param newExtraTimeBlocks new number of blocks
+     */
+    function setExtraChallengeTimeBlocks(uint64 newExtraTimeBlocks) external;
+
+    /**
+     * @notice Set base stake required for an assertion
+     * @param newBaseStake maximum avmgas to be used per block
+     */
+    function setBaseStake(uint256 newBaseStake) external;
+
+    /**
+     * @notice Set the token used for stake, where address(0) == eth
+     * @dev Before changing the base stake token, you might need to change the
+     * implementation of the Rollup User logic!
+     * @param newStakeToken address of token used for staking
+     */
+    function setStakeToken(address newStakeToken) external;
+
+    /**
+     * @notice Set max time variation from actual time for sequencer inbox
+     * @param maxTimeVariation the maximum time variation parameters
+     */
+    function setSequencerInboxMaxTimeVariation(
+        ISequencerInbox.MaxTimeVariation memory maxTimeVariation
+    ) external;
+
+    /**
+     * @notice Updates whether an address is authorized to be a batch poster at the sequencer inbox
+     * @param addr the address
+     * @param isBatchPoster if the specified address should be authorized as a batch poster
+     */
+    function setIsBatchPoster(address addr, bool isBatchPoster) external;
+
+    /**
+     * @notice Upgrades the implementation of a beacon controlled by the rollup
+     * @param beacon address of beacon to be upgraded
+     * @param newImplementation new address of implementation
+     */
+    function upgradeBeacon(address beacon, address newImplementation) external;
+
+    function forceResolveChallenge(address[] memory stackerA, address[] memory stackerB) external;
+
+    function forceRefundStaker(address[] memory stacker) external;
+
+    function forceCreateNode(
+        uint64 prevNode,
+        uint256 prevNodeInboxMaxCount,
+        RollupLib.Assertion memory assertion,
+        bytes32 expectedNodeHash
+    ) external;
+
+    function forceConfirmNode(
+        uint64 nodeNum,
+        bytes32 blockHash,
+        bytes32 sendRoot
+    ) external;
+
+    function setLoserStakeEscrow(address newLoserStakerEscrow) external;
+
+    /**
+     * @notice Set the proving WASM module root
+     * @param newWasmModuleRoot new module root
+     */
+    function setWasmModuleRoot(bytes32 newWasmModuleRoot) external;
+}

package/src/rollup/Node.sol

@@ -0,0 +1,99 @@
+// 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;
+
+struct Node {
+    // Hash of the state of the chain as of this node
+    bytes32 stateHash;
+    // Hash of the data that can be challenged
+    bytes32 challengeHash;
+    // Hash of the data that will be committed if this node is confirmed
+    bytes32 confirmData;
+    // Index of the node previous to this one
+    uint64 prevNum;
+    // Deadline at which this node can be confirmed
+    uint64 deadlineBlock;
+    // Deadline at which a child of this node can be confirmed
+    uint64 noChildConfirmedBeforeBlock;
+    // Number of stakers staked on this node. This includes real stakers and zombies
+    uint64 stakerCount;
+    // Number of stakers staked on a child node. This includes real stakers and zombies
+    uint64 childStakerCount;
+    // This value starts at zero and is set to a value when the first child is created. After that it is constant until the node is destroyed or the owner destroys pending nodes
+    uint64 firstChildBlock;
+    // The number of the latest child of this node to be created
+    uint64 latestChildNumber;
+    // The block number when this node was created
+    uint64 createdAtBlock;
+    // A hash of all the data needed to determine this node's validity, to protect against reorgs
+    bytes32 nodeHash;
+}
+
+/**
+ * @notice Utility functions for Node
+ */
+library NodeLib {
+    /**
+     * @notice Initialize a Node
+     * @param _stateHash Initial value of stateHash
+     * @param _challengeHash Initial value of challengeHash
+     * @param _confirmData Initial value of confirmData
+     * @param _prevNum Initial value of prevNum
+     * @param _deadlineBlock Initial value of deadlineBlock
+     * @param _nodeHash Initial value of nodeHash
+     */
+    function createNode(
+        bytes32 _stateHash,
+        bytes32 _challengeHash,
+        bytes32 _confirmData,
+        uint64 _prevNum,
+        uint64 _deadlineBlock,
+        bytes32 _nodeHash
+    ) internal view returns (Node memory) {
+        Node memory node;
+        node.stateHash = _stateHash;
+        node.challengeHash = _challengeHash;
+        node.confirmData = _confirmData;
+        node.prevNum = _prevNum;
+        node.deadlineBlock = _deadlineBlock;
+        node.noChildConfirmedBeforeBlock = _deadlineBlock;
+        node.createdAtBlock = uint64(block.number);
+        node.nodeHash = _nodeHash;
+        return node;
+    }
+
+    /**
+     * @notice Update child properties
+     * @param number The child number to set
+     */
+    function childCreated(Node storage self, uint64 number) internal {
+        if (self.firstChildBlock == 0) {
+            self.firstChildBlock = uint64(block.number);
+        }
+        self.latestChildNumber = number;
+    }
+
+    /**
+     * @notice Update the child confirmed deadline
+     * @param deadline The new deadline to set
+     */
+    function newChildConfirmDeadline(Node storage self, uint64 deadline) internal {
+        self.noChildConfirmedBeforeBlock = deadline;
+    }
+
+    /**
+     * @notice Check whether the current block number has met or passed the node's deadline
+     */
+    function requirePastDeadline(Node memory self) internal view {
+        require(block.number >= self.deadlineBlock, "BEFORE_DEADLINE");
+    }
+
+    /**
+     * @notice Check whether the current block number has met or passed deadline for children of this node to be confirmed
+     */
+    function requirePastChildConfirmDeadline(Node memory self) internal view {
+        require(block.number >= self.noChildConfirmedBeforeBlock, "CHILD_TOO_RECENT");
+    }
+}

package/src/rollup/RollupAdminLogic.sol

@@ -0,0 +1,322 @@
+// 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 {IRollupAdmin, IRollupUser} from "./IRollupLogic.sol";
+import "./RollupCore.sol";
+import "../bridge/IOutbox.sol";
+import "../bridge/ISequencerInbox.sol";
+import "../challenge/IChallengeManager.sol";
+import "../libraries/SecondaryLogicUUPSUpgradeable.sol";
+import "@openzeppelin/contracts/proxy/beacon/UpgradeableBeacon.sol";
+
+import {NO_CHAL_INDEX} from "../libraries/Constants.sol";
+
+contract RollupAdminLogic is RollupCore, IRollupAdmin, SecondaryLogicUUPSUpgradeable {
+    function initialize(Config calldata config, ContractDependencies calldata connectedContracts)
+        external
+        override
+        onlyProxy
+        initializer
+    {
+        delayedBridge = connectedContracts.delayedBridge;
+        sequencerBridge = connectedContracts.sequencerInbox;
+        outbox = connectedContracts.outbox;
+        delayedBridge.setOutbox(address(connectedContracts.outbox), true);
+        rollupEventBridge = connectedContracts.rollupEventBridge;
+        delayedBridge.setInbox(address(connectedContracts.rollupEventBridge), true);
+
+        rollupEventBridge.rollupInitialized(config.chainId);
+        sequencerBridge.addSequencerL2Batch(0, "", 1, IGasRefunder(address(0)));
+
+        challengeManager = connectedContracts.challengeManager;
+
+        Node memory node = createInitialNode();
+        initializeCore(node);
+
+        confirmPeriodBlocks = config.confirmPeriodBlocks;
+        extraChallengeTimeBlocks = config.extraChallengeTimeBlocks;
+        chainId = config.chainId;
+        baseStake = config.baseStake;
+        wasmModuleRoot = config.wasmModuleRoot;
+        // A little over 15 minutes
+        minimumAssertionPeriod = 75;
+
+        // the owner can't access the rollup user facet where escrow is redeemable
+        require(config.loserStakeEscrow != _getAdmin(), "INVALID_ESCROW_ADMIN");
+        // this next check shouldn't be an issue if the owner controls an AdminProxy
+        // that accesses the admin facet, but still seems like a good extra precaution
+        require(config.loserStakeEscrow != config.owner, "INVALID_ESCROW_OWNER");
+        loserStakeEscrow = config.loserStakeEscrow;
+
+        stakeToken = config.stakeToken;
+
+        sequencerBridge.setMaxTimeVariation(config.sequencerInboxMaxTimeVariation);
+
+        emit RollupInitialized(config.wasmModuleRoot, config.chainId);
+    }
+
+    function createInitialNode() private view returns (Node memory) {
+        GlobalState memory emptyGlobalState;
+        bytes32 state = RollupLib.stateHashMem(
+            RollupLib.ExecutionState(emptyGlobalState, MachineStatus.FINISHED),
+            1 // inboxMaxCount - force the first assertion to read a message
+        );
+        return
+            NodeLib.createNode(
+                state,
+                0, // challenge hash (not challengeable)
+                0, // confirm data
+                0, // prev node
+                uint64(block.number), // deadline block (not challengeable)
+                0 // initial node has a node hash of 0
+            );
+    }
+
+    /**
+     * Functions are only to reach this logic contract if the caller is the owner
+     * so there is no need for a redundant onlyOwner check
+     */
+
+    /**
+     * @notice Add a contract authorized to put messages into this rollup's inbox
+     * @param _outbox Outbox contract to add
+     */
+    function setOutbox(IOutbox _outbox) external override {
+        outbox = _outbox;
+        delayedBridge.setOutbox(address(_outbox), true);
+        emit OwnerFunctionCalled(0);
+    }
+
+    /**
+     * @notice Disable an old outbox from interacting with the bridge
+     * @param _outbox Outbox contract to remove
+     */
+    function removeOldOutbox(address _outbox) external override {
+        require(_outbox != address(outbox), "CUR_OUTBOX");
+        delayedBridge.setOutbox(_outbox, false);
+        emit OwnerFunctionCalled(1);
+    }
+
+    /**
+     * @notice Enable or disable an inbox contract
+     * @param _inbox Inbox contract to add or remove
+     * @param _enabled New status of inbox
+     */
+    function setInbox(address _inbox, bool _enabled) external override {
+        delayedBridge.setInbox(address(_inbox), _enabled);
+        emit OwnerFunctionCalled(2);
+    }
+
+    /**
+     * @notice Pause interaction with the rollup contract.
+     * The time spent paused is not incremented in the rollup's timing for node validation.
+     */
+    function pause() external override {
+        _pause();
+        emit OwnerFunctionCalled(3);
+    }
+
+    /**
+     * @notice Resume interaction with the rollup contract
+     */
+    function resume() external override {
+        _unpause();
+        emit OwnerFunctionCalled(4);
+    }
+
+    /// @notice allows the admin to upgrade the primary logic contract (ie rollup admin logic, aka this)
+    /// @dev this function doesn't revert as this primary logic contract is only
+    /// reachable by the proxy's admin
+    function _authorizeUpgrade(address newImplementation) internal override {}
+
+    /// @notice allows the admin to upgrade the secondary logic contract (ie rollup user logic)
+    /// @dev this function doesn't revert as this primary logic contract is only
+    /// reachable by the proxy's admin
+    function _authorizeSecondaryUpgrade(address newImplementation) internal override {}
+
+    /**
+     * @notice Set the addresses of the validator whitelist
+     * @dev It is expected that both arrays are same length, and validator at
+     * position i corresponds to the value at position i
+     * @param _validator addresses to set in the whitelist
+     * @param _val value to set in the whitelist for corresponding address
+     */
+    function setValidator(address[] calldata _validator, bool[] calldata _val) external override {
+        require(_validator.length == _val.length, "WRONG_LENGTH");
+
+        for (uint256 i = 0; i < _validator.length; i++) {
+            isValidator[_validator[i]] = _val[i];
+        }
+        emit OwnerFunctionCalled(6);
+    }
+
+    /**
+     * @notice Set a new owner address for the rollup
+     * @dev it is expected that only the rollup admin can use this facet to set a new owner
+     * @param newOwner address of new rollup owner
+     */
+    function setOwner(address newOwner) external override {
+        _changeAdmin(newOwner);
+        emit OwnerFunctionCalled(7);
+    }
+
+    /**
+     * @notice Set minimum assertion period for the rollup
+     * @param newPeriod new minimum period for assertions
+     */
+    function setMinimumAssertionPeriod(uint256 newPeriod) external override {
+        minimumAssertionPeriod = newPeriod;
+        emit OwnerFunctionCalled(8);
+    }
+
+    /**
+     * @notice Set number of blocks until a node is considered confirmed
+     * @param newConfirmPeriod new number of blocks
+     */
+    function setConfirmPeriodBlocks(uint64 newConfirmPeriod) external override {
+        confirmPeriodBlocks = newConfirmPeriod;
+        emit OwnerFunctionCalled(9);
+    }
+
+    /**
+     * @notice Set number of extra blocks after a challenge
+     * @param newExtraTimeBlocks new number of blocks
+     */
+    function setExtraChallengeTimeBlocks(uint64 newExtraTimeBlocks) external override {
+        extraChallengeTimeBlocks = newExtraTimeBlocks;
+        emit OwnerFunctionCalled(10);
+    }
+
+    /**
+     * @notice Set base stake required for an assertion
+     * @param newBaseStake minimum amount of stake required
+     */
+    function setBaseStake(uint256 newBaseStake) external override {
+        baseStake = newBaseStake;
+        emit OwnerFunctionCalled(12);
+    }
+
+    /**
+     * @notice Set the token used for stake, where address(0) == eth
+     * @dev Before changing the base stake token, you might need to change the
+     * implementation of the Rollup User facet!
+     * @param newStakeToken address of token used for staking
+     */
+    function setStakeToken(address newStakeToken) external override whenPaused {
+        /*
+         * To change the stake token without breaking consistency one would need to:
+         * Pause the system, have all stakers remove their funds,
+         * update the user logic to handle ERC20s, change the stake token, then resume.
+         *
+         * Note: To avoid loss of funds stakers must remove their funds and claim all the
+         * available withdrawable funds before the system is paused.
+         */
+        bool expectERC20Support = newStakeToken != address(0);
+        // this assumes the rollup isn't its own admin. if needed, instead use a ProxyAdmin by OZ!
+        bool actualERC20Support = IRollupUser(address(this)).isERC20Enabled();
+        require(actualERC20Support == expectERC20Support, "NO_USER_LOGIC_SUPPORT");
+        require(stakerCount() == 0, "NO_ACTIVE_STAKERS");
+        require(totalWithdrawableFunds == 0, "NO_PENDING_WITHDRAW");
+        stakeToken = newStakeToken;
+        emit OwnerFunctionCalled(13);
+    }
+
+    /**
+     * @notice Set max delay for sequencer inbox
+     * @param maxTimeVariation the maximum time variation parameters
+     */
+    function setSequencerInboxMaxTimeVariation(
+        ISequencerInbox.MaxTimeVariation calldata maxTimeVariation
+    ) external override {
+        sequencerBridge.setMaxTimeVariation(maxTimeVariation);
+        emit OwnerFunctionCalled(14);
+    }
+
+    /**
+     * @notice Updates whether an address is authorized to be a batch poster at the sequencer inbox
+     * @param addr the address
+     * @param isBatchPoster if the specified address should be authorized as a batch poster
+     */
+    function setIsBatchPoster(address addr, bool isBatchPoster) external override {
+        ISequencerInbox(sequencerBridge).setIsBatchPoster(addr, isBatchPoster);
+        emit OwnerFunctionCalled(19);
+    }
+
+    /**
+     * @notice Upgrades the implementation of a beacon controlled by the rollup
+     * @param beacon address of beacon to be upgraded
+     * @param newImplementation new address of implementation
+     */
+    function upgradeBeacon(address beacon, address newImplementation) external override {
+        UpgradeableBeacon(beacon).upgradeTo(newImplementation);
+        emit OwnerFunctionCalled(20);
+    }
+
+    function forceResolveChallenge(address[] calldata stakerA, address[] calldata stakerB)
+        external
+        override
+        whenPaused
+    {
+        require(stakerA.length == stakerB.length, "WRONG_LENGTH");
+        for (uint256 i = 0; i < stakerA.length; i++) {
+            uint64 chall = inChallenge(stakerA[i], stakerB[i]);
+
+            require(chall != NO_CHAL_INDEX, "NOT_IN_CHALL");
+            clearChallenge(stakerA[i]);
+            clearChallenge(stakerB[i]);
+            challengeManager.clearChallenge(chall);
+        }
+        emit OwnerFunctionCalled(21);
+    }
+
+    function forceRefundStaker(address[] calldata staker) external override whenPaused {
+        for (uint256 i = 0; i < staker.length; i++) {
+            reduceStakeTo(staker[i], 0);
+            turnIntoZombie(staker[i]);
+        }
+        emit OwnerFunctionCalled(22);
+    }
+
+    function forceCreateNode(
+        uint64 prevNode,
+        uint256 prevNodeInboxMaxCount,
+        RollupLib.Assertion calldata assertion,
+        bytes32 expectedNodeHash
+    ) external override whenPaused {
+        require(prevNode == latestConfirmed(), "ONLY_LATEST_CONFIRMED");
+
+        createNewNode(assertion, prevNode, prevNodeInboxMaxCount, expectedNodeHash);
+
+        emit OwnerFunctionCalled(23);
+    }
+
+    function forceConfirmNode(
+        uint64 nodeNum,
+        bytes32 blockHash,
+        bytes32 sendRoot
+    ) external override whenPaused {
+        // this skips deadline, staker and zombie validation
+        confirmNode(nodeNum, blockHash, sendRoot);
+        emit OwnerFunctionCalled(24);
+    }
+
+    function setLoserStakeEscrow(address newLoserStakerEscrow) external override {
+        // escrow holder can't be proxy admin, since escrow is only redeemable through
+        // the primary user logic contract
+        require(newLoserStakerEscrow != _getAdmin(), "INVALID_ESCROW");
+        loserStakeEscrow = newLoserStakerEscrow;
+        emit OwnerFunctionCalled(25);
+    }
+
+    /**
+     * @notice Set the proving WASM module root
+     * @param newWasmModuleRoot new module root
+     */
+    function setWasmModuleRoot(bytes32 newWasmModuleRoot) external override {
+        wasmModuleRoot = newWasmModuleRoot;
+        emit OwnerFunctionCalled(26);
+    }
+}