@arbitrum/nitro-contracts 1.1.0-alpha.1 → 1.1.0-alpha.3

package/src/rollup/BridgeCreator.sol

@@ -1,60 +1,20 @@
 // 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 "../bridge/Bridge.sol";
-import "../bridge/SequencerInbox.sol";
-import "../bridge/ISequencerInbox.sol";
+import "../bridge/IEthBridge.sol";
 import "../bridge/Inbox.sol";
-import "../bridge/Outbox.sol";
-import "./RollupEventInbox.sol";
+import "../rollup/AbsBridgeCreator.sol";
+import "../rollup/RollupEventInbox.sol";
 
-import "../bridge/IBridge.sol";
-import "@openzeppelin/contracts/access/Ownable.sol";
-import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
-
-contract BridgeCreator is Ownable {
-    Bridge public bridgeTemplate;
-    SequencerInbox public sequencerInboxTemplate;
-    Inbox public inboxTemplate;
-    RollupEventInbox public rollupEventInboxTemplate;
-    Outbox public outboxTemplate;
-
-    event TemplatesUpdated();
-
-    constructor() Ownable() {
+contract BridgeCreator is AbsBridgeCreator, IEthBridgeCreator {
+    constructor() AbsBridgeCreator() {
         bridgeTemplate = new Bridge();
-        sequencerInboxTemplate = new SequencerInbox();
         inboxTemplate = new Inbox();
         rollupEventInboxTemplate = new RollupEventInbox();
-        outboxTemplate = new Outbox();
-    }
-
-    function updateTemplates(
-        address _bridgeTemplate,
-        address _sequencerInboxTemplate,
-        address _inboxTemplate,
-        address _rollupEventInboxTemplate,
-        address _outboxTemplate
-    ) external onlyOwner {
-        bridgeTemplate = Bridge(_bridgeTemplate);
-        sequencerInboxTemplate = SequencerInbox(_sequencerInboxTemplate);
-        inboxTemplate = Inbox(_inboxTemplate);
-        rollupEventInboxTemplate = RollupEventInbox(_rollupEventInboxTemplate);
-        outboxTemplate = Outbox(_outboxTemplate);
-
-        emit TemplatesUpdated();
-    }
-
-    struct CreateBridgeFrame {
-        ProxyAdmin admin;
-        Bridge bridge;
-        SequencerInbox sequencerInbox;
-        Inbox inbox;
-        RollupEventInbox rollupEventInbox;
-        Outbox outbox;
     }
 
     function createBridge(
@@ -64,52 +24,21 @@ contract BridgeCreator is Ownable {
     )
         external
         returns (
-            Bridge,
+            IBridge,
             SequencerInbox,
-            Inbox,
-            RollupEventInbox,
+            IInbox,
+            IRollupEventInbox,
             Outbox
         )
     {
-        CreateBridgeFrame memory frame;
-        {
-            frame.bridge = Bridge(
-                address(new TransparentUpgradeableProxy(address(bridgeTemplate), adminProxy, ""))
-            );
-            frame.sequencerInbox = SequencerInbox(
-                address(
-                    new TransparentUpgradeableProxy(address(sequencerInboxTemplate), adminProxy, "")
-                )
-            );
-            frame.inbox = Inbox(
-                address(new TransparentUpgradeableProxy(address(inboxTemplate), adminProxy, ""))
-            );
-            frame.rollupEventInbox = RollupEventInbox(
-                address(
-                    new TransparentUpgradeableProxy(
-                        address(rollupEventInboxTemplate),
-                        adminProxy,
-                        ""
-                    )
-                )
-            );
-            frame.outbox = Outbox(
-                address(new TransparentUpgradeableProxy(address(outboxTemplate), adminProxy, ""))
-            );
-        }
-
-        frame.bridge.initialize(IOwnable(rollup));
-        frame.sequencerInbox.initialize(IBridge(frame.bridge), maxTimeVariation);
-        frame.inbox.initialize(IBridge(frame.bridge), ISequencerInbox(frame.sequencerInbox));
-        frame.rollupEventInbox.initialize(IBridge(frame.bridge));
-        frame.outbox.initialize(IBridge(frame.bridge));
+        return _createBridge(adminProxy, rollup, address(0), maxTimeVariation);
+    }
 
-        return (
-            frame.bridge,
-            frame.sequencerInbox,
-            frame.inbox,
-            frame.rollupEventInbox,
-            frame.outbox
-        );
+    function _initializeBridge(
+        IBridge bridge,
+        IOwnable rollup,
+        address
+    ) internal override {
+        IEthBridge(address(bridge)).initialize(IOwnable(rollup));
     }
 }

package/src/rollup/Config.sol

@@ -0,0 +1,43 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// 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 "../state/GlobalState.sol";
+import "../state/Machine.sol";
+import "../bridge/ISequencerInbox.sol";
+import "../bridge/IBridge.sol";
+import "../bridge/IOutbox.sol";
+import "../bridge/IInbox.sol";
+import "./IRollupEventInbox.sol";
+import "./IRollupLogic.sol";
+import "../challenge/IChallengeManager.sol";
+
+struct Config {
+    uint64 confirmPeriodBlocks;
+    uint64 extraChallengeTimeBlocks;
+    address stakeToken;
+    uint256 baseStake;
+    bytes32 wasmModuleRoot;
+    address owner;
+    address loserStakeEscrow;
+    uint256 chainId;
+    string chainConfig;
+    uint64 genesisBlockNum;
+    ISequencerInbox.MaxTimeVariation sequencerInboxMaxTimeVariation;
+}
+
+struct ContractDependencies {
+    IBridge bridge;
+    ISequencerInbox sequencerInbox;
+    IInbox inbox;
+    IOutbox outbox;
+    IRollupEventInbox rollupEventInbox;
+    IChallengeManager challengeManager;
+    address rollupAdminLogic;
+    IRollupUser rollupUserLogic;
+    // misc contracts that are useful when interacting with the rollup
+    address validatorUtils;
+    address validatorWalletCreator;
+}

package/src/rollup/ERC20BridgeCreator.sol

@@ -0,0 +1,48 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "../rollup/AbsBridgeCreator.sol";
+import "../bridge/ERC20Bridge.sol";
+import "../bridge/IERC20Bridge.sol";
+import "../bridge/ERC20Inbox.sol";
+import "../rollup/IBridgeCreator.sol";
+import "../rollup/ERC20RollupEventInbox.sol";
+
+import "@openzeppelin/contracts/token/ERC20/presets/ERC20PresetFixedSupply.sol";
+
+contract ERC20BridgeCreator is AbsBridgeCreator, IERC20BridgeCreator {
+    constructor() AbsBridgeCreator() {
+        bridgeTemplate = new ERC20Bridge();
+        inboxTemplate = new ERC20Inbox();
+        rollupEventInboxTemplate = new ERC20RollupEventInbox();
+    }
+
+    function createBridge(
+        address adminProxy,
+        address rollup,
+        address nativeToken,
+        ISequencerInbox.MaxTimeVariation memory maxTimeVariation
+    )
+        external
+        returns (
+            IBridge,
+            SequencerInbox,
+            IInbox,
+            IRollupEventInbox,
+            Outbox
+        )
+    {
+        return _createBridge(adminProxy, rollup, nativeToken, maxTimeVariation);
+    }
+
+    function _initializeBridge(
+        IBridge bridge,
+        IOwnable rollup,
+        address nativeToken
+    ) internal override {
+        IERC20Bridge(address(bridge)).initialize(IOwnable(rollup), nativeToken);
+    }
+}

package/src/rollup/ERC20RollupCreator.sol

@@ -0,0 +1,48 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "./AbsRollupCreator.sol";
+import "./ERC20BridgeCreator.sol";
+
+contract ERC20RollupCreator is AbsRollupCreator, IERC20RollupCreator {
+    constructor() AbsRollupCreator() {}
+
+    // After this setup:
+    // Rollup should be the owner of bridge
+    // RollupOwner should be the owner of Rollup's ProxyAdmin
+    // RollupOwner should be the owner of Rollup
+    // Bridge should have a single inbox and outbox
+    function createRollup(
+        Config memory config,
+        address _batchPoster,
+        address[] calldata _validators,
+        address nativeToken
+    ) external override returns (address) {
+        return _createRollup(config, _batchPoster, _validators, nativeToken);
+    }
+
+    function _createBridge(
+        address proxyAdmin,
+        address rollup,
+        ISequencerInbox.MaxTimeVariation memory maxTimeVariation,
+        address nativeToken
+    ) internal override returns (BridgeContracts memory) {
+        (
+            IBridge bridge,
+            ISequencerInbox sequencerInbox,
+            IInbox inbox,
+            IRollupEventInbox rollupEventInbox,
+            IOutbox outbox
+        ) = ERC20BridgeCreator(address(bridgeCreator)).createBridge(
+                proxyAdmin,
+                rollup,
+                nativeToken,
+                maxTimeVariation
+            );
+
+        return BridgeContracts(bridge, sequencerInbox, inbox, rollupEventInbox, outbox);
+    }
+}

package/src/rollup/ERC20RollupEventInbox.sol

@@ -0,0 +1,26 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "./AbsRollupEventInbox.sol";
+import "../bridge/IERC20Bridge.sol";
+
+/**
+ * @title The inbox for rollup protocol events
+ */
+contract ERC20RollupEventInbox is AbsRollupEventInbox {
+    constructor() AbsRollupEventInbox() {}
+
+    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
+            );
+    }
+}

package/src/rollup/IBridgeCreator.sol

@@ -0,0 +1,64 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "./RollupLib.sol";
+import "./IRollupCore.sol";
+import "../bridge/SequencerInbox.sol";
+import "../bridge/Outbox.sol";
+import "../rollup/RollupEventInbox.sol";
+
+interface IBridgeCreator {
+    function updateTemplates(
+        address _bridgeTemplate,
+        address _sequencerInboxTemplate,
+        address _inboxTemplate,
+        address _rollupEventInboxTemplate,
+        address _outboxTemplate
+    ) external;
+
+    function bridgeTemplate() external view returns (IBridge);
+
+    function sequencerInboxTemplate() external view returns (SequencerInbox);
+
+    function inboxTemplate() external view returns (IInbox);
+
+    function rollupEventInboxTemplate() external view returns (IRollupEventInbox);
+
+    function outboxTemplate() external view returns (Outbox);
+}
+
+interface IEthBridgeCreator is IBridgeCreator {
+    function createBridge(
+        address adminProxy,
+        address rollup,
+        ISequencerInbox.MaxTimeVariation memory maxTimeVariation
+    )
+        external
+        returns (
+            IBridge,
+            SequencerInbox,
+            IInbox,
+            IRollupEventInbox,
+            Outbox
+        );
+}
+
+interface IERC20BridgeCreator is IBridgeCreator {
+    function createBridge(
+        address adminProxy,
+        address rollup,
+        address nativeToken,
+        ISequencerInbox.MaxTimeVariation memory maxTimeVariation
+    )
+        external
+        returns (
+            IBridge,
+            SequencerInbox,
+            IInbox,
+            IRollupEventInbox,
+            Outbox
+        );
+}

package/src/rollup/IRollupAdmin.sol

@@ -0,0 +1,138 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// 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 "./IRollupCore.sol";
+import "../bridge/ISequencerInbox.sol";
+import "../bridge/IOutbox.sol";
+import "../bridge/IOwnable.sol";
+import "./Config.sol";
+
+interface IRollupAdmin {
+    event OwnerFunctionCalled(uint256 indexed id);
+
+    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;
+
+    /**
+     * @notice Disable an old outbox from interacting with the bridge
+     * @param _outbox Outbox contract to remove
+     */
+    function removeOldOutbox(address _outbox) external;
+
+    /**
+     * @notice Enable or disable an inbox contract
+     * @param _inbox Inbox contract to add or remove
+     * @param _enabled New status of inbox
+     */
+    function setDelayedInbox(address _inbox, bool _enabled) external;
+
+    /**
+     * @notice Pause interaction with the rollup contract
+     */
+    function pause() external;
+
+    /**
+     * @notice Resume interaction with the rollup contract
+     */
+    function resume() external;
+
+    /**
+     * @notice Set the addresses of the validator whitelist
+     * @dev It is expected that both arrays are same length, and validator at
+     * position i corresponds to the value at position i
+     * @param _validator addresses to set in the whitelist
+     * @param _val value to set in the whitelist for corresponding address
+     */
+    function setValidator(address[] memory _validator, bool[] memory _val) external;
+
+    /**
+     * @notice Set a new owner address for the rollup proxy
+     * @param newOwner address of new rollup owner
+     */
+    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;
+
+    /**
+     * @notice Set number of blocks until a node is considered confirmed
+     * @param newConfirmPeriod new number of blocks until a node is confirmed
+     */
+    function setConfirmPeriodBlocks(uint64 newConfirmPeriod) external;
+
+    /**
+     * @notice Set number of extra blocks after a challenge
+     * @param newExtraTimeBlocks new number of blocks
+     */
+    function setExtraChallengeTimeBlocks(uint64 newExtraTimeBlocks) 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 forceRefundStaker(address[] memory stacker) external;
+
+    function forceCreateNode(
+        uint64 prevNode,
+        uint256 prevNodeInboxMaxCount,
+        Assertion memory assertion,
+        bytes32 expectedNodeHash
+    ) external;
+
+    function forceConfirmNode(
+        uint64 nodeNum,
+        bytes32 blockHash,
+        bytes32 sendRoot
+    ) external;
+
+    function setLoserStakeEscrow(address newLoserStakerEscrow) external;
+
+    /**
+     * @notice Set the proving WASM module root
+     * @param newWasmModuleRoot new module root
+     */
+    function setWasmModuleRoot(bytes32 newWasmModuleRoot) external;
+
+    /**
+     * @notice set a new sequencer inbox contract
+     * @param _sequencerInbox new address of sequencer inbox
+     */
+    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;
+}

package/src/rollup/IRollupCore.sol

@@ -1,11 +1,15 @@
 // 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 "./Node.sol";
-import "./RollupLib.sol";
+import "../bridge/IBridge.sol";
+import "../bridge/IOutbox.sol";
+import "../bridge/IInbox.sol";
+import "./IRollupEventInbox.sol";
+import "../challenge/IChallengeManager.sol";
 
 interface IRollupCore {
     struct Staker {
@@ -24,7 +28,7 @@ interface IRollupCore {
         bytes32 indexed parentNodeHash,
         bytes32 indexed nodeHash,
         bytes32 executionHash,
-        RollupLib.Assertion assertion,
+        Assertion assertion,
         bytes32 afterInboxBatchAcc,
         bytes32 wasmModuleRoot,
         uint256 inboxMaxCount

package/src/rollup/IRollupCreator.sol

@@ -0,0 +1,40 @@
+// 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 "./IBridgeCreator.sol";
+import "./RollupProxy.sol";
+import "../osp/IOneStepProofEntry.sol";
+import "../challenge/IChallengeManager.sol";
+
+interface IRollupCreator {
+    function setTemplates(
+        IBridgeCreator _bridgeCreator,
+        IOneStepProofEntry _osp,
+        IChallengeManager _challengeManagerLogic,
+        IRollupAdmin _rollupAdminLogic,
+        IRollupUser _rollupUserLogic,
+        address _validatorUtils,
+        address _validatorWalletCreator
+    ) external;
+}
+
+interface IEthRollupCreator is IRollupCreator {
+    function createRollup(
+        Config memory config,
+        address _batchPoster,
+        address[] calldata _validators
+    ) external returns (address);
+}
+
+interface IERC20RollupCreator is IRollupCreator {
+    function createRollup(
+        Config memory config,
+        address _batchPoster,
+        address[] calldata _validators,
+        address nativeToken
+    ) external returns (address);
+}

package/src/rollup/IRollupEventInbox.sol

@@ -1,5 +1,5 @@
 // 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;