@arbitrum/nitro-contracts 1.0.0-beta.7 → 1.0.0

package/src/rollup/RollupCreator.sol

@@ -10,7 +10,7 @@ import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
 import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
 import "@openzeppelin/contracts/access/Ownable.sol";
 
-import "../libraries/ArbitrumProxy.sol";
+import "./RollupProxy.sol";
 
 contract RollupCreator is Ownable {
     event RollupCreated(
@@ -59,7 +59,7 @@ contract RollupCreator is Ownable {
         IInbox inbox;
         IRollupEventInbox rollupEventInbox;
         IOutbox outbox;
-        ArbitrumProxy rollup;
+        RollupProxy rollup;
     }
 
     // After this setup:
@@ -104,7 +104,7 @@ contract RollupCreator is Ownable {
             osp
         );
 
-        frame.rollup = new ArbitrumProxy(
+        frame.rollup = new RollupProxy(
             config,
             ContractDependencies({
                 bridge: frame.bridge,

package/src/rollup/RollupEventInbox.sol

@@ -9,16 +9,12 @@ import "../bridge/IBridge.sol";
 import "../bridge/IDelayedMessageProvider.sol";
 import "../libraries/DelegateCallAware.sol";
 import {INITIALIZATION_MSG_TYPE} from "../libraries/MessageTypes.sol";
+import {AlreadyInit, HadZeroInit} from "../libraries/Error.sol";
 
 /**
  * @title The inbox for rollup protocol events
  */
 contract RollupEventInbox is IRollupEventInbox, IDelayedMessageProvider, DelegateCallAware {
-    uint8 internal constant CREATE_NODE_EVENT = 0;
-    uint8 internal constant CONFIRM_NODE_EVENT = 1;
-    uint8 internal constant REJECT_NODE_EVENT = 2;
-    uint8 internal constant STAKE_CREATED_EVENT = 3;
-
     IBridge public override bridge;
     address public override rollup;
 
@@ -28,7 +24,8 @@ contract RollupEventInbox is IRollupEventInbox, IDelayedMessageProvider, Delegat
     }
 
     function initialize(IBridge _bridge) external override onlyDelegated {
-        require(address(bridge) == address(0), "ALREADY_INIT");
+        if (address(bridge) != address(0)) revert AlreadyInit();
+        if (address(_bridge) == address(0)) revert HadZeroInit();
         bridge = _bridge;
         rollup = address(_bridge.rollup());
     }

package/src/rollup/RollupLib.sol

@@ -24,6 +24,7 @@ struct Config {
     address owner;
     address loserStakeEscrow;
     uint256 chainId;
+    uint64 genesisBlockNum;
     ISequencerInbox.MaxTimeVariation sequencerInboxMaxTimeVariation;
 }
 

package/src/{libraries/ArbitrumProxy.sol → rollup/RollupProxy.sol}

@@ -4,10 +4,10 @@
 
 pragma solidity ^0.8.0;
 
-import "./AdminFallbackProxy.sol";
-import "../rollup/IRollupLogic.sol";
+import "../libraries/AdminFallbackProxy.sol";
+import "./IRollupLogic.sol";
 
-contract ArbitrumProxy is AdminFallbackProxy {
+contract RollupProxy is AdminFallbackProxy {
     constructor(Config memory config, ContractDependencies memory connectedContracts)
         AdminFallbackProxy(
             address(connectedContracts.rollupAdminLogic),

package/src/rollup/RollupUserLogic.sol

@@ -9,6 +9,7 @@ import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
 import {IRollupUser} from "./IRollupLogic.sol";
 import "../libraries/UUPSNotUpgradeable.sol";
 import "./RollupCore.sol";
+import {ETH_POS_BLOCK_TIME} from "../libraries/Constants.sol";
 
 abstract contract AbsRollupUserLogic is
     RollupCore,
@@ -20,10 +21,43 @@ abstract contract AbsRollupUserLogic is
     using GlobalStateLib for GlobalState;
 
     modifier onlyValidator() {
-        require(isValidator[msg.sender], "NOT_VALIDATOR");
+        require(isValidator[msg.sender] || validatorWhitelistDisabled, "NOT_VALIDATOR");
         _;
     }
 
+    uint256 internal immutable deployTimeChainId = block.chainid;
+
+    function _chainIdChanged() internal view returns (bool) {
+        return deployTimeChainId != block.chainid;
+    }
+
+    /**
+     * @notice Extra number of blocks the validator can remain inactive before considered inactive
+     *         This is 7 days assuming a 13.2 seconds block time
+     */
+    uint256 public constant VALIDATOR_AFK_BLOCKS = 45818;
+
+    function _validatorIsAfk() internal view returns (bool) {
+        Node memory latestNode = getNodeStorage(latestNodeCreated());
+        if (latestNode.createdAtBlock == 0) return false;
+        if (latestNode.createdAtBlock + confirmPeriodBlocks + VALIDATOR_AFK_BLOCKS < block.number) {
+            return true;
+        }
+        return false;
+    }
+
+    function removeWhitelistAfterFork() external {
+        require(!validatorWhitelistDisabled, "WHITELIST_DISABLED");
+        require(_chainIdChanged(), "CHAIN_ID_NOT_CHANGED");
+        validatorWhitelistDisabled = true;
+    }
+
+    function removeWhitelistAfterValidatorAfk() external {
+        require(!validatorWhitelistDisabled, "WHITELIST_DISABLED");
+        require(_validatorIsAfk(), "VALIDATOR_NOT_AFK");
+        validatorWhitelistDisabled = true;
+    }
+
     function isERC20Enabled() public view override returns (bool) {
         return stakeToken != address(0);
     }
@@ -239,7 +273,7 @@ abstract contract AbsRollupUserLogic is
      * @param globalStates The before and after global state for the first assertion
      * @param numBlocks The number of L2 blocks contained in the first assertion
      * @param secondExecutionHash The execution hash of the second assertion
-     * @param proposedTimes Times that the two nodes were proposed
+     * @param proposedBlocks L1 block numbers that the two nodes were proposed at
      * @param wasmModuleRoots The wasm module roots at the time of the creation of each assertion
      */
     function createChallenge(
@@ -249,7 +283,7 @@ abstract contract AbsRollupUserLogic is
         GlobalState[2] calldata globalStates,
         uint64 numBlocks,
         bytes32 secondExecutionHash,
-        uint256[2] calldata proposedTimes,
+        uint256[2] calldata proposedBlocks,
         bytes32[2] calldata wasmModuleRoots
     ) external onlyValidator whenNotPaused {
         require(nodeNums[0] < nodeNums[1], "WRONG_ORDER");
@@ -274,7 +308,7 @@ abstract contract AbsRollupUserLogic is
             node1.challengeHash ==
                 RollupLib.challengeRootHash(
                     RollupLib.executionHash(machineStatuses, globalStates, numBlocks),
-                    proposedTimes[0],
+                    proposedBlocks[0],
                     wasmModuleRoots[0]
                 ),
             "CHAL_HASH1"
@@ -284,18 +318,18 @@ abstract contract AbsRollupUserLogic is
             node2.challengeHash ==
                 RollupLib.challengeRootHash(
                     secondExecutionHash,
-                    proposedTimes[1],
+                    proposedBlocks[1],
                     wasmModuleRoots[1]
                 ),
             "CHAL_HASH2"
         );
 
         // Calculate upper limit for allowed node proposal time:
-        uint256 commonEndTime = getNodeStorage(node1.prevNum).firstChildBlock +
+        uint256 commonEndBlock = getNodeStorage(node1.prevNum).firstChildBlock +
             // Dispute start: dispute timer for a node starts when its first child is created
-            (node1.deadlineBlock - proposedTimes[0]) +
+            (node1.deadlineBlock - proposedBlocks[0]) +
             extraChallengeTimeBlocks; // add dispute window to dispute start time
-        if (commonEndTime < proposedTimes[1]) {
+        if (commonEndBlock < proposedBlocks[1]) {
             // The 2nd node was created too late; loses challenge automatically.
             completeChallengeImpl(stakers[0], stakers[1]);
             return;
@@ -307,8 +341,9 @@ abstract contract AbsRollupUserLogic is
             globalStates,
             numBlocks,
             wasmModuleRoots,
-            commonEndTime - proposedTimes[0],
-            commonEndTime - proposedTimes[1]
+            // convert from block counts to real second based timestamps
+            (commonEndBlock - proposedBlocks[0]) * ETH_POS_BLOCK_TIME,
+            (commonEndBlock - proposedBlocks[1]) * ETH_POS_BLOCK_TIME
         ); // trusted external call
 
         challengeStarted(stakers[0], stakers[1], challengeIndex);
@@ -366,6 +401,8 @@ abstract contract AbsRollupUserLogic is
         uint256 amountWon = remainingLoserStake / 2;
         increaseStakeBy(winningStaker, amountWon);
         remainingLoserStake -= amountWon;
+        // We deliberately leave loser in challenge state to prevent them from
+        // doing certain thing that are allowed only to parties not in a challenge
         clearChallenge(winningStaker);
         // Credit the other half to the loserStakeEscrow address
         increaseWithdrawableFunds(loserStakeEscrow, remainingLoserStake);

package/src/state/GlobalState.sol

@@ -41,4 +41,11 @@ library GlobalStateLib {
     function getPositionInMessage(GlobalState memory state) internal pure returns (uint64) {
         return state.u64Vals[1];
     }
+
+    function isEmpty(GlobalState calldata state) internal pure returns (bool) {
+        return (state.bytes32Vals[0] == bytes32(0) &&
+            state.bytes32Vals[1] == bytes32(0) &&
+            state.u64Vals[0] == 0 &&
+            state.u64Vals[1] == 0);
+    }
 }

package/src/test-helpers/BridgeTester.sol

@@ -7,6 +7,14 @@ pragma solidity ^0.8.4;
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
 
+import {
+    NotContract,
+    NotRollupOrOwner,
+    NotDelayedInbox,
+    NotSequencerInbox,
+    NotOutbox,
+    InvalidOutboxSet
+} from "../libraries/Error.sol";
 import "../bridge/IBridge.sol";
 import "../bridge/Messages.sol";
 import "../libraries/DelegateCallAware.sol";
@@ -56,6 +64,7 @@ contract BridgeTester is Initializable, DelegateCallAware, IBridge {
     bytes32[] public override delayedInboxAccs;
 
     bytes32[] public override sequencerInboxAccs;
+    uint256 public override sequencerReportedSubMessageCount;
 
     address private constant EMPTY_ACTIVEOUTBOX = address(type(uint160).max);
 
@@ -77,7 +86,12 @@ contract BridgeTester is Initializable, DelegateCallAware, IBridge {
         return allowedOutboxesMap[outbox].allowed;
     }
 
-    function enqueueSequencerMessage(bytes32 dataHash, uint256 afterDelayedMessagesRead)
+    function enqueueSequencerMessage(
+        bytes32 dataHash,
+        uint256 afterDelayedMessagesRead,
+        uint256 prevMessageCount,
+        uint256 newMessageCount
+    )
         external
         returns (
             uint256 seqMessageIndex,
@@ -220,4 +234,6 @@ contract BridgeTester is Initializable, DelegateCallAware, IBridge {
     }
 
     receive() external payable {}
+
+    function acceptFundsFromOldBridge() external payable {}
 }

package/src/test-helpers/InterfaceCompatibilityTester.sol

@@ -0,0 +1,11 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+// solhint-disable-next-line compiler-version
+pragma solidity >=0.6.9 <0.9.0;
+
+import "../bridge/IBridge.sol";
+import "../bridge/IOutbox.sol";
+import "../bridge/IInbox.sol";
+import "../bridge/ISequencerInbox.sol";

package/src/test-helpers/OutboxWithoutOptTester.sol

@@ -4,6 +4,15 @@
 
 pragma solidity ^0.8.4;
 
+import {
+    AlreadyInit,
+    NotRollup,
+    ProofTooLong,
+    PathNotMinimal,
+    UnknownRoot,
+    AlreadySpent,
+    BridgeCallFailed
+} from "../libraries/Error.sol";
 import "../bridge/IBridge.sol";
 import "../bridge/IOutbox.sol";
 import "../libraries/MerkleLib.sol";
@@ -13,7 +22,11 @@ contract OutboxWithoutOptTester is DelegateCallAware, IOutbox {
     address public rollup; // the rollup contract
     IBridge public bridge; // the bridge contract
 
-    mapping(uint256 => bool) public spent; // maps leaf number => if spent
+    function spent(uint256) external pure override returns (bytes32) {
+        revert("NOT_IMPLEMETED");
+    }
+
+    mapping(uint256 => bool) public isSpent; // maps leaf number => if spent
     mapping(bytes32 => bytes32) public roots; // maps root hashes => L2 block hash
 
     struct L2ToL1Context {
@@ -61,7 +74,7 @@ contract OutboxWithoutOptTester is DelegateCallAware, IOutbox {
     }
 
     // @deprecated batch number is now always 0
-    function l2ToL1BatchNum() external pure override returns (uint256) {
+    function l2ToL1BatchNum() external pure returns (uint256) {
         return 0;
     }
 
@@ -93,7 +106,7 @@ contract OutboxWithoutOptTester is DelegateCallAware, IOutbox {
         uint256 l2Timestamp,
         uint256 value,
         bytes calldata data
-    ) external virtual {
+    ) external virtual override {
         bytes32 outputId;
         {
             bytes32 userTx = calculateItemHash(
@@ -128,6 +141,19 @@ contract OutboxWithoutOptTester is DelegateCallAware, IOutbox {
         context = prevContext;
     }
 
+    function executeTransactionSimulation(
+        uint256,
+        address,
+        address,
+        uint256,
+        uint256,
+        uint256,
+        uint256,
+        bytes calldata
+    ) external pure override {
+        revert("Not implemented");
+    }
+
     function recordOutputAsSpent(
         bytes32[] memory proof,
         uint256 index,
@@ -140,8 +166,8 @@ contract OutboxWithoutOptTester is DelegateCallAware, IOutbox {
         bytes32 calcRoot = calculateMerkleRoot(proof, index, item);
         if (roots[calcRoot] == bytes32(0)) revert UnknownRoot(calcRoot);
 
-        if (spent[index]) revert AlreadySpent(index);
-        spent[index] = true;
+        if (isSpent[index]) revert AlreadySpent(index);
+        isSpent[index] = true;
 
         return bytes32(index);
     }
@@ -173,7 +199,7 @@ contract OutboxWithoutOptTester is DelegateCallAware, IOutbox {
         uint256 l2Timestamp,
         uint256 value,
         bytes calldata data
-    ) public pure returns (bytes32) {
+    ) public pure override returns (bytes32) {
         return
             keccak256(abi.encodePacked(l2Sender, to, l2Block, l1Block, l2Timestamp, value, data));
     }
@@ -182,7 +208,7 @@ contract OutboxWithoutOptTester is DelegateCallAware, IOutbox {
         bytes32[] memory proof,
         uint256 path,
         bytes32 item
-    ) public pure returns (bytes32) {
+    ) public pure override returns (bytes32) {
         return MerkleLib.calculateRoot(proof, path, keccak256(abi.encodePacked(item)));
     }
 }