@arbitrum/nitro-contracts 2.0.0 → 3.0.0-alpha.0

package/src/rollup/BridgeCreator.sol

@@ -19,49 +19,71 @@ import "@openzeppelin/contracts/access/Ownable.sol";
 import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
 
 contract BridgeCreator is Ownable {
-    BridgeContracts public ethBasedTemplates;
-    BridgeContracts public erc20BasedTemplates;
+    BridgeTemplates public ethBasedTemplates;
+    BridgeTemplates public erc20BasedTemplates;
 
     event TemplatesUpdated();
     event ERC20TemplatesUpdated();
 
-    struct BridgeContracts {
+    struct BridgeTemplates {
         IBridge bridge;
         ISequencerInbox sequencerInbox;
+        ISequencerInbox delayBufferableSequencerInbox;
         IInboxBase inbox;
         IRollupEventInbox rollupEventInbox;
         IOutbox outbox;
     }
 
+    struct BridgeContracts {
+        IBridge bridge;
+        IInboxBase inbox;
+        ISequencerInbox sequencerInbox;
+        IRollupEventInbox rollupEventInbox;
+        IOutbox outbox;
+    }
+
     constructor(
-        BridgeContracts memory _ethBasedTemplates,
-        BridgeContracts memory _erc20BasedTemplates
+        BridgeTemplates memory _ethBasedTemplates,
+        BridgeTemplates memory _erc20BasedTemplates
     ) Ownable() {
         ethBasedTemplates = _ethBasedTemplates;
         erc20BasedTemplates = _erc20BasedTemplates;
     }
 
-    function updateTemplates(BridgeContracts calldata _newTemplates) external onlyOwner {
+    function updateTemplates(
+        BridgeTemplates calldata _newTemplates
+    ) external onlyOwner {
         ethBasedTemplates = _newTemplates;
         emit TemplatesUpdated();
     }
 
-    function updateERC20Templates(BridgeContracts calldata _newTemplates) external onlyOwner {
+    function updateERC20Templates(
+        BridgeTemplates calldata _newTemplates
+    ) external onlyOwner {
         erc20BasedTemplates = _newTemplates;
         emit ERC20TemplatesUpdated();
     }
 
-    function _createBridge(address adminProxy, BridgeContracts storage templates)
-        internal
-        returns (BridgeContracts memory)
-    {
+    function _createBridge(
+        address adminProxy,
+        BridgeTemplates memory templates,
+        bool isDelayBufferable
+    ) internal returns (BridgeContracts memory) {
         BridgeContracts memory frame;
         frame.bridge = IBridge(
             address(new TransparentUpgradeableProxy(address(templates.bridge), adminProxy, ""))
         );
         frame.sequencerInbox = ISequencerInbox(
             address(
-                new TransparentUpgradeableProxy(address(templates.sequencerInbox), adminProxy, "")
+                new TransparentUpgradeableProxy(
+                    address(
+                        isDelayBufferable
+                            ? templates.delayBufferableSequencerInbox
+                            : templates.sequencerInbox
+                    ),
+                    adminProxy,
+                    ""
+                )
             )
         );
         frame.inbox = IInboxBase(
@@ -82,12 +104,17 @@ contract BridgeCreator is Ownable {
         address adminProxy,
         address rollup,
         address nativeToken,
-        ISequencerInbox.MaxTimeVariation calldata maxTimeVariation
+        ISequencerInbox.MaxTimeVariation calldata maxTimeVariation,
+        BufferConfig calldata bufferConfig
     ) external returns (BridgeContracts memory) {
+        // 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(
             adminProxy,
-            nativeToken == address(0) ? ethBasedTemplates : erc20BasedTemplates
+            nativeToken == address(0) ? ethBasedTemplates : erc20BasedTemplates,
+            isDelayBufferable
         );
 
         // init contracts
@@ -96,7 +123,7 @@ contract BridgeCreator is Ownable {
         } else {
             IERC20Bridge(address(frame.bridge)).initialize(IOwnable(rollup), nativeToken);
         }
-        frame.sequencerInbox.initialize(IBridge(frame.bridge), maxTimeVariation);
+        frame.sequencerInbox.initialize(IBridge(frame.bridge), maxTimeVariation, bufferConfig);
         frame.inbox.initialize(frame.bridge, frame.sequencerInbox);
         frame.rollupEventInbox.initialize(frame.bridge);
         frame.outbox.initialize(frame.bridge);

package/src/rollup/Config.sol

@@ -12,11 +12,10 @@ import "../bridge/IOutbox.sol";
 import "../bridge/IInboxBase.sol";
 import "./IRollupEventInbox.sol";
 import "./IRollupLogic.sol";
-import "../challenge/IChallengeManager.sol";
+import "../challengeV2/EdgeChallengeManager.sol";
 
 struct Config {
     uint64 confirmPeriodBlocks;
-    uint64 extraChallengeTimeBlocks;
     address stakeToken;
     uint256 baseStake;
     bytes32 wasmModuleRoot;
@@ -24,8 +23,19 @@ struct Config {
     address loserStakeEscrow;
     uint256 chainId;
     string chainConfig;
-    uint64 genesisBlockNum;
+    uint256[] miniStakeValues;
     ISequencerInbox.MaxTimeVariation sequencerInboxMaxTimeVariation;
+    uint256 layerZeroBlockEdgeHeight;
+    uint256 layerZeroBigStepEdgeHeight;
+    uint256 layerZeroSmallStepEdgeHeight;
+    /// @notice The execution state to be used in the genesis assertion
+    AssertionState genesisAssertionState;
+    /// @notice The inbox size at the time the genesis execution state was created
+    uint256 genesisInboxCount;
+    address anyTrustFastConfirmer;
+    uint8 numBigStepLevel;
+    uint64 challengeGracePeriodBlocks;
+    BufferConfig bufferConfig;
 }
 
 struct ContractDependencies {
@@ -34,10 +44,8 @@ struct ContractDependencies {
     IInboxBase inbox;
     IOutbox outbox;
     IRollupEventInbox rollupEventInbox;
-    IChallengeManager challengeManager;
-    address rollupAdminLogic;
+    IEdgeChallengeManager challengeManager;
+    address rollupAdminLogic; // this cannot be IRollupAdmin because of circular dependencies
     IRollupUser rollupUserLogic;
-    // misc contracts that are useful when interacting with the rollup
-    address validatorUtils;
     address validatorWalletCreator;
 }

package/src/rollup/DeployHelper.sol

@@ -51,10 +51,7 @@ contract DeployHelper {
         address _nativeToken,
         uint256 maxFeePerGas
     ) internal {
-        uint256 submissionCost = IInboxBase(inbox).calculateRetryableSubmissionFee(
-            0,
-            block.basefee
-        );
+        uint256 submissionCost = IInboxBase(inbox).calculateRetryableSubmissionFee(0, block.basefee);
         uint256 feeAmount = _value + submissionCost + GASLIMIT * maxFeePerGas;
 
         // fund the target L2 address
@@ -63,13 +60,13 @@ contract DeployHelper {
             uint256 feeAmountNativeDenominated = feeAmount;
             uint8 decimals = ERC20(_nativeToken).decimals();
             if (decimals < 18) {
-                feeAmountNativeDenominated = feeAmount / (10**(18 - decimals));
+                feeAmountNativeDenominated = feeAmount / (10 ** (18 - decimals));
                 // round up if necessary
-                if (feeAmountNativeDenominated * (10**(18 - decimals)) < feeAmount) {
+                if (feeAmountNativeDenominated * (10 ** (18 - decimals)) < feeAmount) {
                     feeAmountNativeDenominated++;
                 }
             } else if (decimals > 18) {
-                feeAmountNativeDenominated = feeAmount * (10**(decimals - 18));
+                feeAmountNativeDenominated = feeAmount * (10 ** (decimals - 18));
             }
 
             IERC20Inbox(inbox).createRetryableTicket({
@@ -113,12 +110,7 @@ contract DeployHelper {
             _maxFeePerGas
         );
         _fundAndDeploy(
-            _inbox,
-            ERC2470_VALUE,
-            ERC2470_DEPLOYER,
-            ERC2470_PAYLOAD,
-            _nativeToken,
-            _maxFeePerGas
+            _inbox, ERC2470_VALUE, ERC2470_DEPLOYER, ERC2470_PAYLOAD, _nativeToken, _maxFeePerGas
         );
         _fundAndDeploy(
             _inbox,
@@ -129,12 +121,7 @@ contract DeployHelper {
             _maxFeePerGas
         );
         _fundAndDeploy(
-            _inbox,
-            ERC1820_VALUE,
-            ERC1820_DEPLOYER,
-            ERC1820_PAYLOAD,
-            _nativeToken,
-            _maxFeePerGas
+            _inbox, ERC1820_VALUE, ERC1820_DEPLOYER, ERC1820_PAYLOAD, _nativeToken, _maxFeePerGas
         );
 
         // if paying with ETH refund the caller
@@ -143,18 +130,12 @@ contract DeployHelper {
         }
     }
 
-    function getDeploymentTotalCost(IInboxBase inbox, uint256 maxFeePerGas)
-        public
-        view
-        returns (uint256)
-    {
+    function getDeploymentTotalCost(
+        IInboxBase inbox,
+        uint256 maxFeePerGas
+    ) public view returns (uint256) {
         uint256 submissionCost = inbox.calculateRetryableSubmissionFee(0, block.basefee);
-        return
-            NICK_CREATE2_VALUE +
-            ERC2470_VALUE +
-            ZOLTU_VALUE +
-            ERC1820_VALUE +
-            4 *
-            (submissionCost + GASLIMIT * maxFeePerGas);
+        return NICK_CREATE2_VALUE + ERC2470_VALUE + ZOLTU_VALUE + ERC1820_VALUE
+            + 4 * (submissionCost + GASLIMIT * maxFeePerGas);
     }
 }

package/src/rollup/ERC20RollupEventInbox.sol

@@ -1,11 +1,12 @@
 // Copyright 2021-2022, Offchain Labs, Inc.
-// For license information, see https://github.com/nitro/blob/master/LICENSE
+// For license information, see https://github.com/OffchainLabs/nitro-contracts/blob/main/LICENSE
 // SPDX-License-Identifier: BUSL-1.1
 
 pragma solidity ^0.8.0;
 
 import "./AbsRollupEventInbox.sol";
 import "../bridge/IERC20Bridge.sol";
+import {INITIALIZATION_MSG_TYPE} from "../libraries/MessageTypes.sol";
 
 /**
  * @title The inbox for rollup protocol events
@@ -13,15 +14,13 @@ import "../bridge/IERC20Bridge.sol";
 contract ERC20RollupEventInbox is AbsRollupEventInbox {
     constructor() AbsRollupEventInbox() {}
 
-    function _enqueueInitializationMsg(bytes memory initMsg) internal override returns (uint256) {
+    function _enqueueInitializationMsg(
+        bytes memory initMsg
+    ) internal override returns (uint256) {
         uint256 tokenAmount = 0;
-        return
-            IERC20Bridge(address(bridge)).enqueueDelayedMessage(
-                INITIALIZATION_MSG_TYPE,
-                address(0),
-                keccak256(initMsg),
-                tokenAmount
-            );
+        return IERC20Bridge(address(bridge)).enqueueDelayedMessage(
+            INITIALIZATION_MSG_TYPE, address(0), keccak256(initMsg), tokenAmount
+        );
     }
 
     function _currentDataCostToReport() internal pure override returns (uint256) {

package/src/rollup/FactoryDeployerHelper.sol

@@ -10,7 +10,9 @@ contract FactoryDeployerHelper {
     address public constant DEPLOY_HELPER = address(0x90D68B056c411015eaE3EC0b98AD94E2C91419F1);
     uint256 public constant MAX_FEE_PER_GAS = 100_000_000;
 
-    function deploy(address inbox) external {
+    function deploy(
+        address inbox
+    ) external {
         deploy(inbox, MAX_FEE_PER_GAS);
     }
 
@@ -25,18 +27,14 @@ contract FactoryDeployerHelper {
 }
 
 interface IERC20 {
-    function transferFrom(
-        address from,
-        address to,
-        uint256 value
-    ) external returns (bool);
+    function transferFrom(address from, address to, uint256 value) external returns (bool);
 }
 
 interface IDeployHelper {
-    function getDeploymentTotalCost(address inbox, uint256 maxFeePerGas)
-        external
-        view
-        returns (uint256);
+    function getDeploymentTotalCost(
+        address inbox,
+        uint256 maxFeePerGas
+    ) external view returns (uint256);
 
     function perform(
         address _inbox,

package/src/rollup/IRollupAdmin.sol

@@ -11,22 +11,80 @@ import "../bridge/IOwnable.sol";
 import "./Config.sol";
 
 interface IRollupAdmin {
-    event OwnerFunctionCalled(uint256 indexed id);
+    /// @dev Outbox address was set
+    event OutboxSet(address outbox);
 
-    function initialize(Config calldata config, ContractDependencies calldata connectedContracts)
-        external;
+    /// @dev Old outbox was removed
+    event OldOutboxRemoved(address outbox);
+
+    /// @dev Inbox was enabled or disabled
+    event DelayedInboxSet(address inbox, bool enabled);
+
+    /// @dev A list of validators was set
+    event ValidatorsSet(address[] validators, bool[] enabled);
+
+    /// @dev A new minimum assertion period was set
+    event MinimumAssertionPeriodSet(uint256 newPeriod);
+
+    /// @dev A new validator afk blocks was set
+    event ValidatorAfkBlocksSet(uint256 newPeriod);
+
+    /// @dev New confirm period blocks was set
+    event ConfirmPeriodBlocksSet(uint64 newConfirmPeriod);
+
+    /// @dev Base stake was set
+    event BaseStakeSet(uint256 newBaseStake);
+
+    /// @dev Stakers were force refunded
+    event StakersForceRefunded(address[] staker);
+
+    /// @dev An assertion was force created
+    event AssertionForceCreated(bytes32 indexed assertionHash);
+
+    /// @dev An assertion was force confirmed
+    event AssertionForceConfirmed(bytes32 indexed assertionHash);
+
+    /// @dev New loser stake escrow set
+    event LoserStakeEscrowSet(address newLoserStakerEscrow);
+
+    /// @dev New wasm module root was set
+    event WasmModuleRootSet(bytes32 newWasmModuleRoot);
+
+    /// @dev New sequencer inbox was set
+    event SequencerInboxSet(address newSequencerInbox);
+
+    /// @dev New inbox set
+    event InboxSet(address inbox);
+
+    /// @dev Validator whitelist was disabled or enabled
+    event ValidatorWhitelistDisabledSet(bool _validatorWhitelistDisabled);
+
+    /// @dev AnyTrust fast confirmer was set
+    event AnyTrustFastConfirmerSet(address anyTrustFastConfirmer);
+
+    /// @dev Challenge manager was set
+    event ChallengeManagerSet(address challengeManager);
+
+    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;
+    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;
+    function removeOldOutbox(
+        address _outbox
+    ) external;
 
     /**
      * @notice Enable or disable an inbox contract
@@ -58,81 +116,105 @@ interface IRollupAdmin {
      * @notice Set a new owner address for the rollup proxy
      * @param newOwner address of new rollup owner
      */
-    function setOwner(address newOwner) external;
+    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;
+    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
+     * @notice Set validator afk blocks for the rollup
+     * @param  newAfkBlocks new number of blocks before a validator is considered afk (0 to disable)
+     * @dev    ValidatorAfkBlocks is the number of blocks since the last confirmed
+     *         assertion (or its first child) before the validator whitelist is removed.
+     *         It's important that this time is greater than the max amount of time it can take to
+     *         to confirm an assertion via the normal method. Therefore we need it to be greater
+     *         than max(2* confirmPeriod, 2 * challengePeriod) with some additional margin.
      */
-    function setConfirmPeriodBlocks(uint64 newConfirmPeriod) external;
+    function setValidatorAfkBlocks(
+        uint64 newAfkBlocks
+    ) external;
 
     /**
-     * @notice Set number of extra blocks after a challenge
-     * @param newExtraTimeBlocks new number of blocks
+     * @notice Set number of blocks until a assertion is considered confirmed
+     * @param newConfirmPeriod new number of blocks until a assertion is confirmed
      */
-    function setExtraChallengeTimeBlocks(uint64 newExtraTimeBlocks) external;
+    function setConfirmPeriodBlocks(
+        uint64 newConfirmPeriod
+    ) 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 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 setBaseStake(
+        uint256 newBaseStake
+    ) external;
 
-    function forceRefundStaker(address[] memory stacker) external;
+    function forceRefundStaker(
+        address[] memory stacker
+    ) external;
 
-    function forceCreateNode(
-        uint64 prevNode,
-        uint256 prevNodeInboxMaxCount,
-        Assertion memory assertion,
-        bytes32 expectedNodeHash
+    function forceCreateAssertion(
+        bytes32 prevAssertionHash,
+        AssertionInputs calldata assertion,
+        bytes32 expectedAssertionHash
     ) external;
 
-    function forceConfirmNode(
-        uint64 nodeNum,
-        bytes32 blockHash,
-        bytes32 sendRoot
+    function forceConfirmAssertion(
+        bytes32 assertionHash,
+        bytes32 parentAssertionHash,
+        AssertionState calldata confirmState,
+        bytes32 inboxAcc
     ) external;
 
-    function setLoserStakeEscrow(address newLoserStakerEscrow) external;
+    function setLoserStakeEscrow(
+        address newLoserStakerEscrow
+    ) external;
 
     /**
      * @notice Set the proving WASM module root
      * @param newWasmModuleRoot new module root
      */
-    function setWasmModuleRoot(bytes32 newWasmModuleRoot) external;
+    function setWasmModuleRoot(
+        bytes32 newWasmModuleRoot
+    ) external;
 
     /**
      * @notice set a new sequencer inbox contract
      * @param _sequencerInbox new address of sequencer inbox
      */
-    function setSequencerInbox(address _sequencerInbox) external;
+    function setSequencerInbox(
+        address _sequencerInbox
+    ) external;
 
     /**
      * @notice set the validatorWhitelistDisabled flag
      * @param _validatorWhitelistDisabled new value of validatorWhitelistDisabled, i.e. true = disabled
      */
-    function setValidatorWhitelistDisabled(bool _validatorWhitelistDisabled) external;
+    function setValidatorWhitelistDisabled(
+        bool _validatorWhitelistDisabled
+    ) external;
+
+    /**
+     * @notice set the anyTrustFastConfirmer address
+     * @param _anyTrustFastConfirmer new value of anyTrustFastConfirmer
+     */
+    function setAnyTrustFastConfirmer(
+        address _anyTrustFastConfirmer
+    ) external;
+
+    /**
+     * @notice set a new challengeManager contract
+     * @param _challengeManager new value of challengeManager
+     */
+    function setChallengeManager(
+        address _challengeManager
+    ) external;
 }