@arbitrum/nitro-contracts 3.0.0-alpha.2 → 3.0.0-beta.1

package/src/rollup/BOLDUpgradeAction.sol

@@ -64,6 +64,12 @@ interface IOldRollup {
         uint256 inboxMaxCount
     );
 
+    function paused() external view returns (bool);
+    function isZombie(
+        address staker
+    ) external view returns (bool);
+    function withdrawStakerFunds() external returns (uint256);
+
     function wasmModuleRoot() external view returns (bytes32);
     function latestConfirmed() external view returns (uint64);
     function getNode(
@@ -136,65 +142,6 @@ contract StateHashPreImageLookup {
     }
 }
 
-/// @title  Forwards calls to the rollup so that they can be interpreted as a user
-/// @notice In the upgrade executor we need to access functions on the rollup
-///         but since the upgrade executor is the admin it will always be forwarded to the
-///         rollup admin logic. We create a separate forwarder contract here that just relays
-///         information, since it's not the admin it can access rollup user logic.
-contract RollupReader is IOldRollup {
-    IOldRollup public immutable rollup;
-
-    constructor(
-        IOldRollup _rollup
-    ) {
-        rollup = _rollup;
-    }
-
-    function wasmModuleRoot() external view returns (bytes32) {
-        return rollup.wasmModuleRoot();
-    }
-
-    function latestConfirmed() external view returns (uint64) {
-        return rollup.latestConfirmed();
-    }
-
-    function getNode(
-        uint64 nodeNum
-    ) external view returns (Node memory) {
-        return rollup.getNode(nodeNum);
-    }
-
-    function getStakerAddress(
-        uint64 stakerNum
-    ) external view returns (address) {
-        return rollup.getStakerAddress(stakerNum);
-    }
-
-    function stakerCount() external view returns (uint64) {
-        return rollup.stakerCount();
-    }
-
-    function getStaker(
-        address staker
-    ) external view returns (OldStaker memory) {
-        return rollup.getStaker(staker);
-    }
-
-    function isValidator(
-        address validator
-    ) external view returns (bool) {
-        return rollup.isValidator(validator);
-    }
-
-    function validatorWalletCreator() external view returns (address) {
-        return rollup.validatorWalletCreator();
-    }
-
-    function anyTrustFastConfirmer() external view returns (address) {
-        return rollup.anyTrustFastConfirmer();
-    }
-}
-
 /// @notice Stores an array specified during construction.
 ///         Since the BOLDUpgradeAction is not allowed to have storage,
 ///         we use this contract so it can keep an immutable pointer to an array.
@@ -216,6 +163,7 @@ contract ConstantArrayStorage {
 /// @notice Requires implementation contracts to be pre-deployed and provided in the constructor
 ///         Also requires a lookup contract to be provided that contains the pre-image of the state hash
 ///         that is in the latest confirmed assertion in the current rollup.
+///         The old rollup should be on v1.1.0 or later to allow stake withdrawals after the upgrade
 contract BOLDUpgradeAction {
     using AssertionStateLib for AssertionState;
 
@@ -237,6 +185,9 @@ contract BOLDUpgradeAction {
     address public immutable STAKE_TOKEN;
     uint256 public immutable STAKE_AMOUNT;
     uint256 public immutable CHAIN_ID;
+    uint256 public immutable MINIMUM_ASSERTION_PERIOD;
+    uint64 public immutable VALIDATOR_AFK_BLOCKS;
+
     bool public immutable DISABLE_VALIDATOR_WHITELIST;
     uint64 public immutable CHALLENGE_GRACE_PERIOD_BLOCKS;
     address public immutable MINI_STAKE_AMOUNTS_STORAGE;
@@ -255,7 +206,6 @@ contract BOLDUpgradeAction {
     ProxyAdmin public immutable PROXY_ADMIN_SEQUENCER_INBOX;
     ProxyAdmin public immutable PROXY_ADMIN_INBOX;
     StateHashPreImageLookup public immutable PREIMAGE_LOOKUP;
-    RollupReader public immutable ROLLUP_READER;
 
     // new contract implementations
     address public immutable IMPL_BRIDGE;
@@ -263,8 +213,6 @@ contract BOLDUpgradeAction {
     address public immutable IMPL_INBOX;
     address public immutable IMPL_REI;
     address public immutable IMPL_OUTBOX;
-    // the old rollup, but with whenNotPaused protection removed from stake withdrawal functions
-    address public immutable IMPL_PATCHED_OLD_ROLLUP_USER;
     address public immutable IMPL_NEW_ROLLUP_USER;
     address public immutable IMPL_NEW_ROLLUP_ADMIN;
     address public immutable IMPL_CHALLENGE_MANAGER;
@@ -278,6 +226,8 @@ contract BOLDUpgradeAction {
         uint256 stakeAmt;
         uint256[] miniStakeAmounts;
         uint256 chainId;
+        uint256 minimumAssertionPeriod;
+        uint64 validatorAfkBlocks;
         bool disableValidatorWhitelist;
         uint256 blockLeafSize;
         uint256 bigStepLeafSize;
@@ -303,7 +253,6 @@ contract BOLDUpgradeAction {
         address inbox;
         address rei;
         address outbox;
-        address oldRollupUser;
         address newRollupUser;
         address newRollupAdmin;
         address challengeManager;
@@ -341,19 +290,19 @@ contract BOLDUpgradeAction {
         PROXY_ADMIN_SEQUENCER_INBOX = ProxyAdmin(proxyAdmins.seqInbox);
         PROXY_ADMIN_INBOX = ProxyAdmin(proxyAdmins.inbox);
         PREIMAGE_LOOKUP = new StateHashPreImageLookup();
-        ROLLUP_READER = new RollupReader(contracts.rollup);
 
         IMPL_BRIDGE = implementations.bridge;
         IMPL_SEQUENCER_INBOX = implementations.seqInbox;
         IMPL_INBOX = implementations.inbox;
         IMPL_REI = implementations.rei;
         IMPL_OUTBOX = implementations.outbox;
-        IMPL_PATCHED_OLD_ROLLUP_USER = implementations.oldRollupUser;
         IMPL_NEW_ROLLUP_USER = implementations.newRollupUser;
         IMPL_NEW_ROLLUP_ADMIN = implementations.newRollupAdmin;
         IMPL_CHALLENGE_MANAGER = implementations.challengeManager;
 
         CHAIN_ID = settings.chainId;
+        MINIMUM_ASSERTION_PERIOD = settings.minimumAssertionPeriod;
+        VALIDATOR_AFK_BLOCKS = settings.validatorAfkBlocks;
         CONFIRM_PERIOD_BLOCKS = settings.confirmPeriodBlocks;
         CHALLENGE_PERIOD_BLOCKS = settings.challengePeriodBlocks;
         STAKE_TOKEN = settings.stakeToken;
@@ -376,15 +325,15 @@ contract BOLDUpgradeAction {
     function cleanupOldRollup() private {
         IOldRollupAdmin(address(OLD_ROLLUP)).pause();
 
-        uint64 stakerCount = ROLLUP_READER.stakerCount();
+        uint64 stakerCount = OLD_ROLLUP.stakerCount();
         // since we for-loop these stakers we set an arbitrary limit - we dont
         // expect any instances to have close to this number of stakers
         if (stakerCount > 50) {
             stakerCount = 50;
         }
         for (uint64 i = 0; i < stakerCount;) {
-            address stakerAddr = ROLLUP_READER.getStakerAddress(i);
-            OldStaker memory staker = ROLLUP_READER.getStaker(stakerAddr);
+            address stakerAddr = OLD_ROLLUP.getStakerAddress(i);
+            OldStaker memory staker = OLD_ROLLUP.getStaker(stakerAddr);
             if (staker.isStaked && staker.currentChallenge == 0) {
                 address[] memory stakersToRefund = new address[](1);
                 stakersToRefund[0] = stakerAddr;
@@ -395,11 +344,6 @@ contract BOLDUpgradeAction {
                 i++;
             }
         }
-
-        // upgrade the rollup to one that allows validators to withdraw even whilst paused
-        DoubleLogicUUPSUpgradeable(address(OLD_ROLLUP)).upgradeSecondaryTo(
-            IMPL_PATCHED_OLD_ROLLUP_USER
-        );
     }
 
     /// @dev    Create a config for the new rollup - fetches the latest confirmed
@@ -407,7 +351,7 @@ contract BOLDUpgradeAction {
     function createConfig() private view returns (Config memory) {
         // fetch the assertion associated with the latest confirmed state
         bytes32 latestConfirmedStateHash =
-            ROLLUP_READER.getNode(ROLLUP_READER.latestConfirmed()).stateHash;
+            OLD_ROLLUP.getNode(OLD_ROLLUP.latestConfirmed()).stateHash;
         (ExecutionState memory genesisExecState, uint256 inboxMaxCount) =
             PREIMAGE_LOOKUP.get(latestConfirmedStateHash);
 
@@ -431,11 +375,13 @@ contract BOLDUpgradeAction {
             confirmPeriodBlocks: CONFIRM_PERIOD_BLOCKS,
             stakeToken: STAKE_TOKEN,
             baseStake: STAKE_AMOUNT,
-            wasmModuleRoot: ROLLUP_READER.wasmModuleRoot(),
+            wasmModuleRoot: OLD_ROLLUP.wasmModuleRoot(),
             owner: address(this), // upgrade executor is the owner
             loserStakeEscrow: EXCESS_STAKE_RECEIVER, // additional funds get sent to the l1 timelock
             chainId: CHAIN_ID,
             chainConfig: "", // we can use an empty chain config it wont be used in the rollup initialization because we check if the rei is already connected there
+            minimumAssertionPeriod: MINIMUM_ASSERTION_PERIOD,
+            validatorAfkBlocks: VALIDATOR_AFK_BLOCKS,
             miniStakeValues: ConstantArrayStorage(MINI_STAKE_AMOUNTS_STORAGE).array(),
             sequencerInboxMaxTimeVariation: maxTimeVariation,
             layerZeroBlockEdgeHeight: BLOCK_LEAF_SIZE,
@@ -496,17 +442,6 @@ contract BOLDUpgradeAction {
             PROXY_ADMIN_SEQUENCER_INBOX.upgrade(sequencerInbox, IMPL_SEQUENCER_INBOX);
         }
 
-        // verify
-        require(
-            PROXY_ADMIN_SEQUENCER_INBOX.getProxyImplementation(sequencerInbox)
-                == IMPL_SEQUENCER_INBOX,
-            "DelayBuffer: new seq inbox implementation not set"
-        );
-        require(
-            ISequencerInbox(SEQ_INBOX).isDelayBufferable() == IS_DELAY_BUFFERABLE,
-            "DelayBuffer: isDelayBufferable not set"
-        );
-
         (uint256 delayBlocks, uint256 futureBlocks, uint256 delaySeconds, uint256 futureSeconds) =
             ISequencerInbox(SEQ_INBOX).maxTimeVariation();
 
@@ -528,17 +463,31 @@ contract BOLDUpgradeAction {
             })
         );
 
-        // verify
-        (uint256 _delayBlocks, uint256 _futureBlocks, uint256 _delaySeconds, uint256 _futureSeconds)
-        = ISequencerInbox(SEQ_INBOX).maxTimeVariation();
-        require(_delayBlocks == delayBlocks, "DelayBuffer: delayBlocks not set");
-        require(_delaySeconds == delaySeconds, "DelayBuffer: delaySeconds not set");
-        require(_futureBlocks == futureBlocks, "DelayBuffer: futureBlocks not set");
-        require(_futureSeconds == futureSeconds, "DelayBuffer: futureSeconds not set");
-
         ISequencerInbox(SEQ_INBOX).updateRollupAddress();
     }
 
+    function expectedRollupAddress(
+        address deployer,
+        uint256 chainId
+    ) public pure returns (address) {
+        bytes32 rollupSalt = keccak256(abi.encode(chainId));
+        return Create2Upgradeable.computeAddress(
+            rollupSalt, keccak256(type(RollupProxy).creationCode), deployer
+        );
+    }
+
+    function validateRollupDeployedAtAddress(
+        address rollupAddress,
+        address deployer,
+        uint256 chainId
+    ) external view {
+        require(
+            (rollupAddress.code.length > 0)
+                && expectedRollupAddress(deployer, chainId) == rollupAddress,
+            "ADDR_MISMATCH"
+        );
+    }
+
     function perform(
         address[] memory validators
     ) external {
@@ -570,18 +519,18 @@ contract BOLDUpgradeAction {
             challengeManager: challengeManager,
             rollupAdminLogic: IMPL_NEW_ROLLUP_ADMIN,
             rollupUserLogic: IRollupUser(IMPL_NEW_ROLLUP_USER),
-            validatorWalletCreator: ROLLUP_READER.validatorWalletCreator()
+            validatorWalletCreator: OLD_ROLLUP.validatorWalletCreator()
         });
 
         // upgrade the surrounding contracts eg bridge, outbox, seq inbox, rollup event inbox
         // to set of the new rollup address
-        bytes32 rollupSalt = keccak256(abi.encode(config));
-        address expectedRollupAddress =
-            Create2Upgradeable.computeAddress(rollupSalt, keccak256(type(RollupProxy).creationCode));
-        upgradeSurroundingContracts(expectedRollupAddress);
+        // this is different from the typical salt, it is ok because the caller should deploy the upgrade only once for each chainid
+        bytes32 rollupSalt = keccak256(abi.encode(config.chainId));
+        address _expectedRollupAddress = expectedRollupAddress(address(this), config.chainId);
+        upgradeSurroundingContracts(_expectedRollupAddress);
 
         challengeManager.initialize({
-            _assertionChain: IAssertionChain(expectedRollupAddress),
+            _assertionChain: IAssertionChain(_expectedRollupAddress),
             _challengePeriodBlocks: CHALLENGE_PERIOD_BLOCKS,
             _oneStepProofEntry: OSP,
             layerZeroBlockEdgeHeight: config.layerZeroBlockEdgeHeight,
@@ -594,7 +543,7 @@ contract BOLDUpgradeAction {
         });
 
         RollupProxy rollup = new RollupProxy{salt: rollupSalt}();
-        require(address(rollup) == expectedRollupAddress, "UNEXPCTED_ROLLUP_ADDR");
+        require(address(rollup) == _expectedRollupAddress, "UNEXPCTED_ROLLUP_ADDR");
 
         // initialize the rollup with this contract as owner to set batch poster and validators
         // it will transfer the ownership back to the actual owner later
@@ -606,7 +555,7 @@ contract BOLDUpgradeAction {
         if (validators.length != 0) {
             bool[] memory _vals = new bool[](validators.length);
             for (uint256 i = 0; i < validators.length; i++) {
-                require(ROLLUP_READER.isValidator(validators[i]), "UNEXPECTED_NEW_VALIDATOR");
+                require(OLD_ROLLUP.isValidator(validators[i]), "UNEXPECTED_NEW_VALIDATOR");
                 _vals[i] = true;
             }
             IRollupAdmin(address(rollup)).setValidator(validators, _vals);
@@ -616,7 +565,7 @@ contract BOLDUpgradeAction {
         }
 
         // anyTrustFastConfirmer only exists since v2.0.0, but the old rollup can be on an older version
-        try ROLLUP_READER.anyTrustFastConfirmer() returns (address anyTrustFastConfirmer) {
+        try OLD_ROLLUP.anyTrustFastConfirmer() returns (address anyTrustFastConfirmer) {
             if (anyTrustFastConfirmer != address(0)) {
                 IRollupAdmin(address(rollup)).setAnyTrustFastConfirmer(anyTrustFastConfirmer);
             }
@@ -626,6 +575,6 @@ contract BOLDUpgradeAction {
 
         IRollupAdmin(address(rollup)).setOwner(actualOwner);
 
-        emit RollupMigrated(expectedRollupAddress, address(challengeManager));
+        emit RollupMigrated(_expectedRollupAddress, address(challengeManager));
     }
 }

package/src/rollup/BridgeCreator.sol

@@ -65,17 +65,22 @@ contract BridgeCreator is Ownable {
     }
 
     function _createBridge(
+        bytes32 create2Salt,
         address adminProxy,
         BridgeTemplates memory templates,
         bool isDelayBufferable
     ) internal returns (BridgeContracts memory) {
         BridgeContracts memory frame;
         frame.bridge = IBridge(
-            address(new TransparentUpgradeableProxy(address(templates.bridge), adminProxy, ""))
+            address(
+                new TransparentUpgradeableProxy{salt: create2Salt}(
+                    address(templates.bridge), adminProxy, ""
+                )
+            )
         );
         frame.sequencerInbox = ISequencerInbox(
             address(
-                new TransparentUpgradeableProxy(
+                new TransparentUpgradeableProxy{salt: create2Salt}(
                     address(
                         isDelayBufferable
                             ? templates.delayBufferableSequencerInbox
@@ -87,15 +92,25 @@ contract BridgeCreator is Ownable {
             )
         );
         frame.inbox = IInboxBase(
-            address(new TransparentUpgradeableProxy(address(templates.inbox), adminProxy, ""))
+            address(
+                new TransparentUpgradeableProxy{salt: create2Salt}(
+                    address(templates.inbox), adminProxy, ""
+                )
+            )
         );
         frame.rollupEventInbox = IRollupEventInbox(
             address(
-                new TransparentUpgradeableProxy(address(templates.rollupEventInbox), adminProxy, "")
+                new TransparentUpgradeableProxy{salt: create2Salt}(
+                    address(templates.rollupEventInbox), adminProxy, ""
+                )
             )
         );
         frame.outbox = IOutbox(
-            address(new TransparentUpgradeableProxy(address(templates.outbox), adminProxy, ""))
+            address(
+                new TransparentUpgradeableProxy{salt: create2Salt}(
+                    address(templates.outbox), adminProxy, ""
+                )
+            )
         );
         return frame;
     }
@@ -107,11 +122,14 @@ contract BridgeCreator is Ownable {
         ISequencerInbox.MaxTimeVariation calldata maxTimeVariation,
         BufferConfig calldata bufferConfig
     ) external returns (BridgeContracts memory) {
+        // use create2 salt to ensure deterministic addresses
+        bytes32 create2Salt = keccak256(abi.encode(msg.data, msg.sender));
         // create delay bufferable sequencer inbox if threshold is non-zero
         bool isDelayBufferable = bufferConfig.threshold != 0;
 
         // create ETH-based bridge if address zero is provided for native token, otherwise create ERC20-based bridge
         BridgeContracts memory frame = _createBridge(
+            create2Salt,
             adminProxy,
             nativeToken == address(0) ? ethBasedTemplates : erc20BasedTemplates,
             isDelayBufferable

package/src/rollup/Config.sol

@@ -23,6 +23,8 @@ struct Config {
     address loserStakeEscrow;
     uint256 chainId;
     string chainConfig;
+    uint256 minimumAssertionPeriod;
+    uint64 validatorAfkBlocks;
     uint256[] miniStakeValues;
     ISequencerInbox.MaxTimeVariation sequencerInboxMaxTimeVariation;
     uint256 layerZeroBlockEdgeHeight;

package/src/rollup/RollupAdminLogic.sol

@@ -53,12 +53,12 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, DoubleLogicUUPSUpgradeabl
         chainId = config.chainId;
         baseStake = config.baseStake;
         wasmModuleRoot = config.wasmModuleRoot;
-        // A little over 15 minutes
-        minimumAssertionPeriod = 75;
-        // ValidatorAfkBlocks is defaulted to 28 days assuming a 12 seconds block time.
+        // minimumAssertionPeriod was defaulted to 75 which is a little over 15 minutes
+        minimumAssertionPeriod = config.minimumAssertionPeriod;
+        // ValidatorAfkBlocks was defaulted to 201600 which is 28 days assuming a 12 seconds block time.
         // Since it can take 14 days under normal circumstances to confirm an assertion, this means
         // the validators will have been inactive for a further 14 days before the whitelist is removed.
-        validatorAfkBlocks = 201600;
+        validatorAfkBlocks = config.validatorAfkBlocks;
         challengeGracePeriodBlocks = config.challengeGracePeriodBlocks;
 
         // loser stake is now sent directly to loserStakeEscrow, it must not

package/build/contracts/src/rollup/BOLDUpgradeAction.sol/RollupReader.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/a354aaf7cb79bc63f750c0ca36db8cc9.json"
-}