@arbitrum/nitro-contracts 1.1.0-beta.0 → 1.1.0-beta.2

package/src/rollup/RollupCreator.sol

@@ -33,6 +33,16 @@ contract RollupCreator is Ownable {
     );
     event TemplatesUpdated();
 
+    struct RollupDeploymentParams {
+        Config config;
+        address batchPoster;
+        address[] validators;
+        uint256 maxDataSize;
+        address nativeToken;
+        bool deployFactoriesToL2;
+        uint256 maxFeePerGasForRetryables;
+    }
+
     BridgeCreator public bridgeCreator;
     IOneStepProofEntry public osp;
     IChallengeManager public challengeManagerTemplate;
@@ -81,53 +91,52 @@ contract RollupCreator is Ownable {
      * @dev - config.rollupOwner should have executor role on upgradeExecutor
      * @dev - Bridge should have a single inbox and outbox
      * @dev - Validators and batch poster should be set if provided
-     * @param config       The configuration for the rollup
-     * @param _batchPoster The address of the batch poster, not used when set to zero address
-     * @param _validators  The list of validator addresses, not used when set to empty list
-     * @param _nativeToken Address of the custom fee token used by rollup. If rollup is ETH-based address(0) should be provided
-     * @param _deployFactoriesToL2 Whether to deploy L2 factories using retryable tickets. If true, retryables need to be paid for in native currency.
-     *                             Deploying factories via retryable tickets at rollup creation time is the most reliable method to do it since it
-     *                             doesn't require paying the L1 gas. If deployment is not done as part of rollup creation TX, there is a risk that
-     *                             anyone can try to deploy factories and potentially burn the nonce 0 (ie. due to gas price spike when doing direct
-     *                             L2 TX). That would mean we permanently lost capability to deploy deterministic factory at expected address.
-     * @param _maxFeePerGasForRetryables price bid for L2 execution.
+     * @param deployParams The parameters for the rollup deployment. It consists of:
+     *          - config        The configuration for the rollup
+     *          - batchPoster   The address of the batch poster, not used when set to zero address
+     *          - validators    The list of validator addresses, not used when set to empty list
+     *          - nativeToken   Address of the custom fee token used by rollup. If rollup is ETH-based address(0) should be provided
+     *          - deployFactoriesToL2 Whether to deploy L2 factories using retryable tickets. If true, retryables need to be paid for in native currency.
+     *                          Deploying factories via retryable tickets at rollup creation time is the most reliable method to do it since it
+     *                          doesn't require paying the L1 gas. If deployment is not done as part of rollup creation TX, there is a risk that
+     *                          anyone can try to deploy factories and potentially burn the nonce 0 (ie. due to gas price spike when doing direct
+     *                          L2 TX). That would mean we permanently lost capability to deploy deterministic factory at expected address.
+     *          - maxFeePerGasForRetryables price bid for L2 execution.
      * @return The address of the newly created rollup
      */
-    function createRollup(
-        Config memory config,
-        address _batchPoster,
-        address[] memory _validators,
-        uint256 _maxDataSize,
-        address _nativeToken,
-        bool _deployFactoriesToL2,
-        uint256 _maxFeePerGasForRetryables
-    ) public payable returns (address) {
-        {
-            // Make sure the immutable maxDataSize is as expected
-            (, ISequencerInbox ethSequencerInbox, IInboxBase ethInbox, , ) = bridgeCreator
-                .ethBasedTemplates();
-            require(_maxDataSize == ethSequencerInbox.maxDataSize(), "SI_MAX_DATA_SIZE_MISMATCH");
-            require(_maxDataSize == ethInbox.maxDataSize(), "I_MAX_DATA_SIZE_MISMATCH");
+    function createRollup(RollupDeploymentParams memory deployParams)
+        public
+        payable
+        returns (address)
+    {
+        // Make sure the immutable maxDataSize is as expected
+        (, ISequencerInbox ethSequencerInbox, IInboxBase ethInbox, , ) = bridgeCreator
+            .ethBasedTemplates();
+        require(
+            deployParams.maxDataSize == ethSequencerInbox.maxDataSize(),
+            "SI_MAX_DATA_SIZE_MISMATCH"
+        );
+        require(deployParams.maxDataSize == ethInbox.maxDataSize(), "I_MAX_DATA_SIZE_MISMATCH");
 
-            (, ISequencerInbox erc20SequencerInbox, IInboxBase erc20Inbox, , ) = bridgeCreator
-                .erc20BasedTemplates();
-            require(_maxDataSize == erc20SequencerInbox.maxDataSize(), "SI_MAX_DATA_SIZE_MISMATCH");
-            require(_maxDataSize == erc20Inbox.maxDataSize(), "I_MAX_DATA_SIZE_MISMATCH");
-        }
+        (, ISequencerInbox erc20SequencerInbox, IInboxBase erc20Inbox, , ) = bridgeCreator
+            .erc20BasedTemplates();
+        require(
+            deployParams.maxDataSize == erc20SequencerInbox.maxDataSize(),
+            "SI_MAX_DATA_SIZE_MISMATCH"
+        );
+        require(deployParams.maxDataSize == erc20Inbox.maxDataSize(), "I_MAX_DATA_SIZE_MISMATCH");
 
         // create proxy admin which will manage bridge contracts
         ProxyAdmin proxyAdmin = new ProxyAdmin();
 
         // Create the rollup proxy to figure out the address and initialize it later
-        RollupProxy rollup = new RollupProxy{
-            salt: keccak256(abi.encode(config, _batchPoster, _validators, _maxDataSize))
-        }();
+        RollupProxy rollup = new RollupProxy{salt: keccak256(abi.encode(deployParams))}();
 
         BridgeCreator.BridgeContracts memory bridgeContracts = bridgeCreator.createBridge(
             address(proxyAdmin),
             address(rollup),
-            _nativeToken,
-            config.sequencerInboxMaxTimeVariation
+            deployParams.nativeToken,
+            deployParams.config.sequencerInboxMaxTimeVariation
         );
 
         IChallengeManager challengeManager = IChallengeManager(
@@ -147,16 +156,16 @@ contract RollupCreator is Ownable {
         );
 
         // deploy and init upgrade executor
-        address upgradeExecutor = _deployUpgradeExecutor(config.owner, proxyAdmin);
+        address upgradeExecutor = _deployUpgradeExecutor(deployParams.config.owner, proxyAdmin);
 
         // upgradeExecutor shall be proxyAdmin's owner
         proxyAdmin.transferOwnership(address(upgradeExecutor));
 
         // initialize the rollup with this contract as owner to set batch poster and validators
         // it will transfer the ownership to the upgrade executor later
-        config.owner = address(this);
+        deployParams.config.owner = address(this);
         rollup.initializeProxy(
-            config,
+            deployParams.config,
             ContractDependencies({
                 bridge: bridgeContracts.bridge,
                 sequencerInbox: bridgeContracts.sequencerInbox,
@@ -172,32 +181,32 @@ contract RollupCreator is Ownable {
         );
 
         // setting batch poster, if the address provided is not zero address
-        if (_batchPoster != address(0)) {
-            bridgeContracts.sequencerInbox.setIsBatchPoster(_batchPoster, true);
+        if (deployParams.batchPoster != address(0)) {
+            bridgeContracts.sequencerInbox.setIsBatchPoster(deployParams.batchPoster, true);
         }
 
         // Call setValidator on the newly created rollup contract just if validator set is not empty
-        if (_validators.length != 0) {
-            bool[] memory _vals = new bool[](_validators.length);
-            for (uint256 i = 0; i < _validators.length; i++) {
+        if (deployParams.validators.length != 0) {
+            bool[] memory _vals = new bool[](deployParams.validators.length);
+            for (uint256 i = 0; i < deployParams.validators.length; i++) {
                 _vals[i] = true;
             }
-            IRollupAdmin(address(rollup)).setValidator(_validators, _vals);
+            IRollupAdmin(address(rollup)).setValidator(deployParams.validators, _vals);
         }
 
         IRollupAdmin(address(rollup)).setOwner(address(upgradeExecutor));
 
-        if (_deployFactoriesToL2) {
+        if (deployParams.deployFactoriesToL2) {
             _deployFactories(
                 address(bridgeContracts.inbox),
-                _nativeToken,
-                _maxFeePerGasForRetryables
+                deployParams.nativeToken,
+                deployParams.maxFeePerGasForRetryables
             );
         }
 
         emit RollupCreated(
             address(rollup),
-            _nativeToken,
+            deployParams.nativeToken,
             address(bridgeContracts.inbox),
             address(bridgeContracts.outbox),
             address(bridgeContracts.rollupEventInbox),

package/src/rollup/RollupUserLogic.sol

@@ -27,6 +27,11 @@ abstract contract AbsRollupUserLogic is
         _;
     }
 
+    modifier whenNotPausedOrDeprecated() {
+        require(!paused() || address(bridge.rollup()) != address(this), "PAUSED_AND_ACTIVE");
+        _;
+    }
+
     uint256 internal immutable deployTimeChainId = block.chainid;
 
     function _chainIdChanged() internal view returns (bool) {
@@ -234,7 +239,12 @@ abstract contract AbsRollupUserLogic is
      * and move it to the desired node.
      * @param stakerAddress Address of the staker whose stake is refunded
      */
-    function returnOldDeposit(address stakerAddress) external override onlyValidator whenNotPaused {
+    function returnOldDeposit(address stakerAddress)
+        external
+        override
+        onlyValidator
+        whenNotPausedOrDeprecated
+    {
         require(latestStakedNode(stakerAddress) <= latestConfirmed(), "TOO_RECENT");
         requireUnchallengedStaker(stakerAddress);
         withdrawStaker(stakerAddress);
@@ -258,7 +268,7 @@ abstract contract AbsRollupUserLogic is
      * @notice Reduce the amount staked for the sender (difference between initial amount staked and target is creditted back to the sender).
      * @param target Target amount of stake for the staker. If this is below the current minimum, it will be set to minimum instead
      */
-    function reduceDeposit(uint256 target) external onlyValidator whenNotPaused {
+    function reduceDeposit(uint256 target) external onlyValidator whenNotPausedOrDeprecated {
         requireUnchallengedStaker(msg.sender);
         uint256 currentRequired = currentRequiredStake();
         if (target < currentRequired) {
@@ -659,7 +669,13 @@ contract RollupUserLogic is AbsRollupUserLogic, IRollupUser {
     /**
      * @notice Withdraw uncommitted funds owned by sender from the rollup chain
      */
-    function withdrawStakerFunds() external override onlyValidator whenNotPaused returns (uint256) {
+    function withdrawStakerFunds()
+        external
+        override
+        onlyValidator
+        whenNotPausedOrDeprecated
+        returns (uint256)
+    {
         uint256 amount = withdrawFunds(msg.sender);
         // This is safe because it occurs after all checks and effects
         // solhint-disable-next-line avoid-low-level-calls
@@ -731,7 +747,13 @@ contract ERC20RollupUserLogic is AbsRollupUserLogic, IRollupUserERC20 {
     /**
      * @notice Withdraw uncommitted funds owned by sender from the rollup chain
      */
-    function withdrawStakerFunds() external override onlyValidator whenNotPaused returns (uint256) {
+    function withdrawStakerFunds()
+        external
+        override
+        onlyValidator
+        whenNotPausedOrDeprecated
+        returns (uint256)
+    {
         uint256 amount = withdrawFunds(msg.sender);
         // This is safe because it occurs after all checks and effects
         require(IERC20Upgradeable(stakeToken).transfer(msg.sender, amount), "TRANSFER_FAILED");

package/src/test-helpers/BridgeTester.sol

@@ -74,6 +74,10 @@ contract BridgeTester is Initializable, DelegateCallAware, IBridge, IEthBridge {
         rollup = rollup_;
     }
 
+    function updateRollupAddress(IOwnable _rollup) external {
+        rollup = _rollup;
+    }
+
     function activeOutbox() public view returns (address) {
         if (_activeOutbox == EMPTY_ACTIVEOUTBOX) return address(uint160(0));
         return _activeOutbox;

package/src/test-helpers/OutboxWithoutOptTester.sol

@@ -48,12 +48,18 @@ contract OutboxWithoutOptTester is DelegateCallAware, IOutbox {
         rollup = address(_bridge.rollup());
     }
 
+    function postUpgradeInit() external {}
+
     function updateSendRoot(bytes32 root, bytes32 l2BlockHash) external override {
         //if (msg.sender != rollup) revert NotRollup(msg.sender, rollup);  //test only!!!
         roots[root] = l2BlockHash;
         emit SendRootUpdated(root, l2BlockHash);
     }
 
+    function updateRollupAddress() external onlyDelegated onlyProxyOwner {
+        rollup = address(bridge.rollup());
+    }
+
     /// @notice When l2ToL1Sender returns a nonzero address, the message was originated by an L2 account
     /// When the return value is zero, that means this is a system message
     /// @dev the l2ToL1Sender behaves as the tx.origin, the msg.sender should be validated to protect against reentrancies