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

package/src/rollup/RollupCreator.sol

@@ -28,7 +28,6 @@ contract RollupCreator is Ownable {
         address sequencerInbox,
         address bridge,
         address upgradeExecutor,
-        address validatorUtils,
         address validatorWalletCreator
     );
     event TemplatesUpdated();
@@ -46,12 +45,11 @@ contract RollupCreator is Ownable {
 
     BridgeCreator public bridgeCreator;
     IOneStepProofEntry public osp;
-    IChallengeManager public challengeManagerTemplate;
+    IEdgeChallengeManager public challengeManagerTemplate;
     IRollupAdmin public rollupAdminLogic;
     IRollupUser public rollupUserLogic;
     IUpgradeExecutor public upgradeExecutorLogic;
 
-    address public validatorUtils;
     address public validatorWalletCreator;
 
     DeployHelper public l2FactoriesDeployer;
@@ -64,11 +62,10 @@ contract RollupCreator is Ownable {
     function setTemplates(
         BridgeCreator _bridgeCreator,
         IOneStepProofEntry _osp,
-        IChallengeManager _challengeManagerLogic,
+        IEdgeChallengeManager _challengeManagerLogic,
         IRollupAdmin _rollupAdminLogic,
         IRollupUser _rollupUserLogic,
         IUpgradeExecutor _upgradeExecutorLogic,
-        address _validatorUtils,
         address _validatorWalletCreator,
         DeployHelper _l2FactoriesDeployer
     ) external onlyOwner {
@@ -78,12 +75,41 @@ contract RollupCreator is Ownable {
         rollupAdminLogic = _rollupAdminLogic;
         rollupUserLogic = _rollupUserLogic;
         upgradeExecutorLogic = _upgradeExecutorLogic;
-        validatorUtils = _validatorUtils;
         validatorWalletCreator = _validatorWalletCreator;
         l2FactoriesDeployer = _l2FactoriesDeployer;
         emit TemplatesUpdated();
     }
 
+    // internal function to workaround stack limit
+    function createChallengeManager(
+        address rollupAddr,
+        address proxyAdminAddr,
+        Config memory config
+    ) internal returns (IEdgeChallengeManager) {
+        IEdgeChallengeManager challengeManager = IEdgeChallengeManager(
+            address(
+                new TransparentUpgradeableProxy(
+                    address(challengeManagerTemplate), proxyAdminAddr, ""
+                )
+            )
+        );
+
+        challengeManager.initialize({
+            _assertionChain: IAssertionChain(rollupAddr),
+            _challengePeriodBlocks: config.confirmPeriodBlocks,
+            _oneStepProofEntry: osp,
+            layerZeroBlockEdgeHeight: config.layerZeroBlockEdgeHeight,
+            layerZeroBigStepEdgeHeight: config.layerZeroBigStepEdgeHeight,
+            layerZeroSmallStepEdgeHeight: config.layerZeroSmallStepEdgeHeight,
+            _stakeToken: IERC20(config.stakeToken),
+            _stakeAmounts: config.miniStakeValues,
+            _excessStakeReceiver: config.owner,
+            _numBigStepLevel: config.numBigStepLevel
+        });
+
+        return challengeManager;
+    }
+
     /**
      * @notice Create a new rollup
      * @dev After this setup:
@@ -107,30 +133,45 @@ contract RollupCreator is Ownable {
      *          - batchPosterManager The address which has the ability to rotate batch poster keys
      * @return The address of the newly created rollup
      */
-    function createRollup(RollupDeploymentParams memory deployParams)
-        public
-        payable
-        returns (address)
-    {
+    function createRollup(
+        RollupDeploymentParams memory deployParams
+    ) public payable returns (address) {
         {
             // Make sure the immutable maxDataSize is as expected
-            (, ISequencerInbox ethSequencerInbox, IInboxBase ethInbox, , ) = bridgeCreator
-                .ethBasedTemplates();
+            (
+                ,
+                ISequencerInbox ethSequencerInbox,
+                ISequencerInbox ethDelayBufferableSequencerInbox,
+                IInboxBase ethInbox,
+                ,
+            ) = bridgeCreator.ethBasedTemplates();
             require(
                 deployParams.maxDataSize == ethSequencerInbox.maxDataSize(),
                 "SI_MAX_DATA_SIZE_MISMATCH"
             );
+            require(
+                deployParams.maxDataSize == ethDelayBufferableSequencerInbox.maxDataSize(),
+                "SI_MAX_DATA_SIZE_MISMATCH"
+            );
             require(deployParams.maxDataSize == ethInbox.maxDataSize(), "I_MAX_DATA_SIZE_MISMATCH");
 
-            (, ISequencerInbox erc20SequencerInbox, IInboxBase erc20Inbox, , ) = bridgeCreator
-                .erc20BasedTemplates();
+            (
+                ,
+                ISequencerInbox erc20SequencerInbox,
+                ISequencerInbox erc20DelayBufferableSequencerInbox,
+                IInboxBase erc20Inbox,
+                ,
+            ) = bridgeCreator.erc20BasedTemplates();
             require(
                 deployParams.maxDataSize == erc20SequencerInbox.maxDataSize(),
                 "SI_MAX_DATA_SIZE_MISMATCH"
             );
             require(
-                deployParams.maxDataSize == erc20Inbox.maxDataSize(),
-                "I_MAX_DATA_SIZE_MISMATCH"
+                deployParams.maxDataSize == erc20DelayBufferableSequencerInbox.maxDataSize(),
+                "SI_MAX_DATA_SIZE_MISMATCH"
+            );
+            require(
+                deployParams.maxDataSize == erc20Inbox.maxDataSize(), "I_MAX_DATA_SIZE_MISMATCH"
             );
         }
 
@@ -144,24 +185,12 @@ contract RollupCreator is Ownable {
             address(proxyAdmin),
             address(rollup),
             deployParams.nativeToken,
-            deployParams.config.sequencerInboxMaxTimeVariation
+            deployParams.config.sequencerInboxMaxTimeVariation,
+            deployParams.config.bufferConfig
         );
 
-        IChallengeManager challengeManager = IChallengeManager(
-            address(
-                new TransparentUpgradeableProxy(
-                    address(challengeManagerTemplate),
-                    address(proxyAdmin),
-                    ""
-                )
-            )
-        );
-        challengeManager.initialize(
-            IChallengeResultReceiver(address(rollup)),
-            bridgeContracts.sequencerInbox,
-            bridgeContracts.bridge,
-            osp
-        );
+        IEdgeChallengeManager challengeManager =
+            createChallengeManager(address(rollup), address(proxyAdmin), deployParams.config);
 
         // deploy and init upgrade executor
         address upgradeExecutor = _deployUpgradeExecutor(deployParams.config.owner, proxyAdmin);
@@ -183,7 +212,6 @@ contract RollupCreator is Ownable {
                 challengeManager: challengeManager,
                 rollupAdminLogic: address(rollupAdminLogic),
                 rollupUserLogic: rollupUserLogic,
-                validatorUtils: validatorUtils,
                 validatorWalletCreator: validatorWalletCreator
             })
         );
@@ -226,22 +254,19 @@ contract RollupCreator is Ownable {
             address(bridgeContracts.sequencerInbox),
             address(bridgeContracts.bridge),
             address(upgradeExecutor),
-            address(validatorUtils),
             address(validatorWalletCreator)
         );
         return address(rollup);
     }
 
-    function _deployUpgradeExecutor(address rollupOwner, ProxyAdmin proxyAdmin)
-        internal
-        returns (address)
-    {
+    function _deployUpgradeExecutor(
+        address rollupOwner,
+        ProxyAdmin proxyAdmin
+    ) internal returns (address) {
         IUpgradeExecutor upgradeExecutor = IUpgradeExecutor(
             address(
                 new TransparentUpgradeableProxy(
-                    address(upgradeExecutorLogic),
-                    address(proxyAdmin),
-                    bytes("")
+                    address(upgradeExecutorLogic), address(proxyAdmin), bytes("")
                 )
             )
         );
@@ -259,24 +284,20 @@ contract RollupCreator is Ownable {
     ) internal {
         if (_nativeToken == address(0)) {
             // we need to fund 4 retryable tickets
-            uint256 cost = l2FactoriesDeployer.getDeploymentTotalCost(
-                IInboxBase(_inbox),
-                _maxFeePerGas
-            );
+            uint256 cost =
+                l2FactoriesDeployer.getDeploymentTotalCost(IInboxBase(_inbox), _maxFeePerGas);
 
             // do it
             l2FactoriesDeployer.perform{value: cost}(_inbox, _nativeToken, _maxFeePerGas);
 
             // refund the caller
             // solhint-disable-next-line avoid-low-level-calls
-            (bool sent, ) = msg.sender.call{value: address(this).balance}("");
+            (bool sent,) = msg.sender.call{value: address(this).balance}("");
             require(sent, "Refund failed");
         } else {
             // Transfer fee token amount needed to pay for retryable fees to the inbox.
-            uint256 totalFee = l2FactoriesDeployer.getDeploymentTotalCost(
-                IInboxBase(_inbox),
-                _maxFeePerGas
-            );
+            uint256 totalFee =
+                l2FactoriesDeployer.getDeploymentTotalCost(IInboxBase(_inbox), _maxFeePerGas);
 
             // calculate the fee amount in the native token's decimals
             uint8 decimals = ERC20(_nativeToken).decimals();
@@ -285,28 +306,21 @@ contract RollupCreator is Ownable {
             if (decimals < 18) {
                 uint256 gasCost = _maxFeePerGas * 21_000;
                 uint256 nickCreate2Cost = _scaleDownToNativeDecimals(
-                    l2FactoriesDeployer.NICK_CREATE2_VALUE() + gasCost,
-                    decimals
+                    l2FactoriesDeployer.NICK_CREATE2_VALUE() + gasCost, decimals
                 );
                 uint256 erc2470Cost = _scaleDownToNativeDecimals(
-                    l2FactoriesDeployer.ERC2470_VALUE() + gasCost,
-                    decimals
+                    l2FactoriesDeployer.ERC2470_VALUE() + gasCost, decimals
                 );
                 uint256 zoltuCreate2Cost = _scaleDownToNativeDecimals(
-                    l2FactoriesDeployer.ZOLTU_VALUE() + gasCost,
-                    decimals
+                    l2FactoriesDeployer.ZOLTU_VALUE() + gasCost, decimals
                 );
                 uint256 erc1820Cost = _scaleDownToNativeDecimals(
-                    l2FactoriesDeployer.ERC1820_VALUE() + gasCost,
-                    decimals
+                    l2FactoriesDeployer.ERC1820_VALUE() + gasCost, decimals
                 );
                 totalFeeNativeDenominated =
-                    nickCreate2Cost +
-                    erc2470Cost +
-                    zoltuCreate2Cost +
-                    erc1820Cost;
+                    nickCreate2Cost + erc2470Cost + zoltuCreate2Cost + erc1820Cost;
             } else if (decimals > 18) {
-                totalFeeNativeDenominated = totalFee * (10**(decimals - 18));
+                totalFeeNativeDenominated = totalFee * (10 ** (decimals - 18));
             }
 
             IERC20(_nativeToken).safeTransferFrom(msg.sender, _inbox, totalFeeNativeDenominated);
@@ -316,16 +330,15 @@ contract RollupCreator is Ownable {
         }
     }
 
-    function _scaleDownToNativeDecimals(uint256 amount, uint8 decimals)
-        internal
-        pure
-        returns (uint256)
-    {
+    function _scaleDownToNativeDecimals(
+        uint256 amount,
+        uint8 decimals
+    ) internal pure returns (uint256) {
         uint256 scaledAmount = amount;
         if (decimals < 18) {
-            scaledAmount = amount / (10**(18 - decimals));
+            scaledAmount = amount / (10 ** (18 - decimals));
             // round up if necessary
-            if (scaledAmount * (10**(18 - decimals)) < amount) {
+            if (scaledAmount * (10 ** (18 - decimals)) < amount) {
                 scaledAmount++;
             }
         }

package/src/rollup/RollupEventInbox.sol

@@ -6,6 +6,7 @@ pragma solidity ^0.8.0;
 
 import "./AbsRollupEventInbox.sol";
 import "../bridge/IEthBridge.sol";
+import {INITIALIZATION_MSG_TYPE} from "../libraries/MessageTypes.sol";
 
 /**
  * @title The inbox for rollup protocol events
@@ -13,13 +14,12 @@ import "../bridge/IEthBridge.sol";
 contract RollupEventInbox is AbsRollupEventInbox {
     constructor() AbsRollupEventInbox() {}
 
-    function _enqueueInitializationMsg(bytes memory initMsg) internal override returns (uint256) {
-        return
-            IEthBridge(address(bridge)).enqueueDelayedMessage(
-                INITIALIZATION_MSG_TYPE,
-                address(0),
-                keccak256(initMsg)
-            );
+    function _enqueueInitializationMsg(
+        bytes memory initMsg
+    ) internal override returns (uint256) {
+        return IEthBridge(address(bridge)).enqueueDelayedMessage(
+            INITIALIZATION_MSG_TYPE, address(0), keccak256(initMsg)
+        );
     }
 
     function _currentDataCostToReport() internal view override returns (uint256) {

package/src/rollup/RollupLib.sol

@@ -4,110 +4,74 @@
 
 pragma solidity ^0.8.0;
 
-import "../challenge/IChallengeManager.sol";
-import "../challenge/ChallengeLib.sol";
 import "../state/GlobalState.sol";
 import "../bridge/ISequencerInbox.sol";
 
 import "../bridge/IBridge.sol";
 import "../bridge/IOutbox.sol";
 import "../bridge/IInboxBase.sol";
-import "./Node.sol";
+import "./Assertion.sol";
 import "./IRollupEventInbox.sol";
+import "../challengeV2/EdgeChallengeManager.sol";
 
 library RollupLib {
     using GlobalStateLib for GlobalState;
+    using AssertionStateLib for AssertionState;
 
-    function stateHash(ExecutionState calldata execState, uint256 inboxMaxCount)
-        internal
-        pure
-        returns (bytes32)
-    {
-        return
-            keccak256(
-                abi.encodePacked(
-                    execState.globalState.hash(),
-                    inboxMaxCount,
-                    execState.machineStatus
-                )
-            );
-    }
-
-    /// @dev same as stateHash but expects execState in memory instead of calldata
-    function stateHashMem(ExecutionState memory execState, uint256 inboxMaxCount)
-        internal
-        pure
-        returns (bytes32)
-    {
-        return
-            keccak256(
-                abi.encodePacked(
-                    execState.globalState.hash(),
-                    inboxMaxCount,
-                    execState.machineStatus
-                )
-            );
-    }
-
-    function executionHash(Assertion memory assertion) internal pure returns (bytes32) {
-        MachineStatus[2] memory statuses;
-        statuses[0] = assertion.beforeState.machineStatus;
-        statuses[1] = assertion.afterState.machineStatus;
-        GlobalState[2] memory globalStates;
-        globalStates[0] = assertion.beforeState.globalState;
-        globalStates[1] = assertion.afterState.globalState;
-        // TODO: benchmark how much this abstraction adds of gas overhead
-        return executionHash(statuses, globalStates, assertion.numBlocks);
-    }
-
-    function executionHash(
-        MachineStatus[2] memory statuses,
-        GlobalState[2] memory globalStates,
-        uint64 numBlocks
+    // The `assertionHash` contains all the information needed to determine an assertion's validity.
+    // This helps protect validators against reorgs by letting them bind their assertion to the current chain state.
+    function assertionHash(
+        bytes32 parentAssertionHash,
+        AssertionState memory afterState,
+        bytes32 inboxAcc
     ) internal pure returns (bytes32) {
-        bytes32[] memory segments = new bytes32[](2);
-        segments[0] = ChallengeLib.blockStateHash(statuses[0], globalStates[0].hash());
-        segments[1] = ChallengeLib.blockStateHash(statuses[1], globalStates[1].hash());
-        return ChallengeLib.hashChallengeState(0, numBlocks, segments);
+        // we can no longer have `hasSibling` in the assertion hash as it would allow identical assertions
+        return assertionHash(parentAssertionHash, afterState.hash(), inboxAcc);
     }
 
-    function challengeRootHash(
-        bytes32 execution,
-        uint256 proposedTime,
-        bytes32 wasmModuleRoot
+    // Takes in a hash of the afterState instead of the afterState itself
+    function assertionHash(
+        bytes32 parentAssertionHash,
+        bytes32 afterStateHash,
+        bytes32 inboxAcc
     ) internal pure returns (bytes32) {
-        return keccak256(abi.encodePacked(execution, proposedTime, wasmModuleRoot));
-    }
-
-    function confirmHash(Assertion memory assertion) internal pure returns (bytes32) {
-        return
-            confirmHash(
-                assertion.afterState.globalState.getBlockHash(),
-                assertion.afterState.globalState.getSendRoot()
-            );
+        // we can no longer have `hasSibling` in the assertion hash as it would allow identical assertions
+        return keccak256(abi.encodePacked(parentAssertionHash, afterStateHash, inboxAcc));
     }
 
-    function confirmHash(bytes32 blockHash, bytes32 sendRoot) internal pure returns (bytes32) {
-        return keccak256(abi.encodePacked(blockHash, sendRoot));
+    // All these should be emited in AssertionCreated event
+    function configHash(
+        bytes32 wasmModuleRoot,
+        uint256 requiredStake,
+        address challengeManager,
+        uint64 confirmPeriodBlocks,
+        uint64 nextInboxPosition
+    ) internal pure returns (bytes32) {
+        return keccak256(
+            abi.encodePacked(
+                wasmModuleRoot,
+                requiredStake,
+                challengeManager,
+                confirmPeriodBlocks,
+                nextInboxPosition
+            )
+        );
     }
 
-    function nodeHash(
-        bool hasSibling,
-        bytes32 lastHash,
-        bytes32 assertionExecHash,
-        bytes32 inboxAcc,
-        bytes32 wasmModuleRoot
-    ) internal pure returns (bytes32) {
-        uint8 hasSiblingInt = hasSibling ? 1 : 0;
-        return
-            keccak256(
-                abi.encodePacked(
-                    hasSiblingInt,
-                    lastHash,
-                    assertionExecHash,
-                    inboxAcc,
-                    wasmModuleRoot
-                )
-            );
+    function validateConfigHash(
+        ConfigData calldata configData,
+        bytes32 _configHash
+    ) internal pure {
+        require(
+            _configHash
+                == configHash(
+                    configData.wasmModuleRoot,
+                    configData.requiredStake,
+                    configData.challengeManager,
+                    configData.confirmPeriodBlocks,
+                    configData.nextInboxPosition
+                ),
+            "CONFIG_HASH_MISMATCH"
+        );
     }
 }

package/src/rollup/RollupProxy.sol

@@ -9,23 +9,19 @@ import "./IRollupAdmin.sol";
 import "./Config.sol";
 
 contract RollupProxy is AdminFallbackProxy {
-    function initializeProxy(Config memory config, ContractDependencies memory connectedContracts)
-        external
-    {
+    function initializeProxy(
+        Config memory config,
+        ContractDependencies memory connectedContracts
+    ) external {
         if (
-            _getAdmin() == address(0) &&
-            _getImplementation() == address(0) &&
-            _getSecondaryImplementation() == address(0)
+            _getAdmin() == address(0) && _getImplementation() == address(0)
+                && _getSecondaryImplementation() == address(0)
         ) {
             _initialize(
                 address(connectedContracts.rollupAdminLogic),
-                abi.encodeWithSelector(
-                    IRollupAdmin.initialize.selector,
-                    config,
-                    connectedContracts
-                ),
+                abi.encodeCall(IRollupAdmin.initialize, (config, connectedContracts)),
                 address(connectedContracts.rollupUserLogic),
-                abi.encodeWithSelector(IRollupUserAbs.initialize.selector, config.stakeToken),
+                abi.encodeCall(IRollupUser.initialize, (config.stakeToken)),
                 config.owner
             );
         } else {