@arbitrum/nitro-contracts 1.0.0-beta.1

package/src/rollup/RollupCreator.sol

@@ -0,0 +1,133 @@
+// 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 "../bridge/Bridge.sol";
+import "../bridge/SequencerInbox.sol";
+import "../bridge/Inbox.sol";
+import "../bridge/Outbox.sol";
+import "./RollupEventBridge.sol";
+import "./BridgeCreator.sol";
+
+import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
+import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+import "../libraries/ArbitrumProxy.sol";
+import "./RollupUserLogic.sol";
+import "./RollupAdminLogic.sol";
+import "../bridge/IBridge.sol";
+
+import "./RollupLib.sol";
+
+contract RollupCreator is Ownable {
+    event RollupCreated(
+        address indexed rollupAddress,
+        address inboxAddress,
+        address adminProxy,
+        address sequencerInbox,
+        address delayedBridge
+    );
+    event TemplatesUpdated();
+
+    BridgeCreator public bridgeCreator;
+    IOneStepProofEntry public osp;
+    IChallengeManager public challengeManagerTemplate;
+    IRollupAdmin public rollupAdminLogic;
+    IRollupUser public rollupUserLogic;
+
+    constructor() Ownable() {}
+
+    function setTemplates(
+        BridgeCreator _bridgeCreator,
+        IOneStepProofEntry _osp,
+        IChallengeManager _challengeManagerLogic,
+        IRollupAdmin _rollupAdminLogic,
+        IRollupUser _rollupUserLogic
+    ) external onlyOwner {
+        bridgeCreator = _bridgeCreator;
+        osp = _osp;
+        challengeManagerTemplate = _challengeManagerLogic;
+        rollupAdminLogic = _rollupAdminLogic;
+        rollupUserLogic = _rollupUserLogic;
+        emit TemplatesUpdated();
+    }
+
+    struct CreateRollupFrame {
+        ProxyAdmin admin;
+        Bridge delayedBridge;
+        SequencerInbox sequencerInbox;
+        Inbox inbox;
+        RollupEventBridge rollupEventBridge;
+        Outbox outbox;
+        ArbitrumProxy rollup;
+    }
+
+    // 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 expectedRollupAddr)
+        external
+        returns (address)
+    {
+        CreateRollupFrame memory frame;
+        frame.admin = new ProxyAdmin();
+
+        (
+            frame.delayedBridge,
+            frame.sequencerInbox,
+            frame.inbox,
+            frame.rollupEventBridge,
+            frame.outbox
+        ) = bridgeCreator.createBridge(
+            address(frame.admin),
+            expectedRollupAddr,
+            config.sequencerInboxMaxTimeVariation
+        );
+
+        frame.admin.transferOwnership(config.owner);
+
+        IChallengeManager challengeManager = IChallengeManager(
+            address(
+                new TransparentUpgradeableProxy(
+                    address(challengeManagerTemplate),
+                    address(frame.admin),
+                    ""
+                )
+            )
+        );
+        challengeManager.initialize(
+            IChallengeResultReceiver(expectedRollupAddr),
+            frame.sequencerInbox,
+            frame.delayedBridge,
+            osp
+        );
+
+        frame.rollup = new ArbitrumProxy(
+            config,
+            ContractDependencies({
+                delayedBridge: frame.delayedBridge,
+                sequencerInbox: frame.sequencerInbox,
+                outbox: frame.outbox,
+                rollupEventBridge: frame.rollupEventBridge,
+                challengeManager: challengeManager,
+                rollupAdminLogic: rollupAdminLogic,
+                rollupUserLogic: rollupUserLogic
+            })
+        );
+        require(address(frame.rollup) == expectedRollupAddr, "WRONG_ROLLUP_ADDR");
+
+        emit RollupCreated(
+            address(frame.rollup),
+            address(frame.inbox),
+            address(frame.admin),
+            address(frame.sequencerInbox),
+            address(frame.delayedBridge)
+        );
+        return address(frame.rollup);
+    }
+}

package/src/rollup/RollupEventBridge.sol

@@ -0,0 +1,46 @@
+// 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 "./IRollupLogic.sol";
+
+import "../bridge/IBridge.sol";
+import "../bridge/IMessageProvider.sol";
+import "../libraries/DelegateCallAware.sol";
+import {INITIALIZATION_MSG_TYPE} from "../libraries/MessageTypes.sol";
+
+/**
+ * @title The inbox for rollup protocol events
+ */
+contract RollupEventBridge is IMessageProvider, DelegateCallAware {
+    uint8 internal constant CREATE_NODE_EVENT = 0;
+    uint8 internal constant CONFIRM_NODE_EVENT = 1;
+    uint8 internal constant REJECT_NODE_EVENT = 2;
+    uint8 internal constant STAKE_CREATED_EVENT = 3;
+
+    IBridge public bridge;
+    address public rollup;
+
+    modifier onlyRollup() {
+        require(msg.sender == rollup, "ONLY_ROLLUP");
+        _;
+    }
+
+    function initialize(address _bridge, address _rollup) external onlyDelegated {
+        require(rollup == address(0), "ALREADY_INIT");
+        bridge = IBridge(_bridge);
+        rollup = _rollup;
+    }
+
+    function rollupInitialized(uint256 chainId) external onlyRollup {
+        bytes memory initMsg = abi.encodePacked(chainId);
+        uint256 num = bridge.enqueueDelayedMessage(
+            INITIALIZATION_MSG_TYPE,
+            address(0),
+            keccak256(initMsg)
+        );
+        emit InboxMessageDelivered(num, initMsg);
+    }
+}

package/src/rollup/RollupLib.sol

@@ -0,0 +1,135 @@
+// 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 "../challenge/IChallengeManager.sol";
+import "../challenge/ChallengeLib.sol";
+import "../state/GlobalState.sol";
+import "../bridge/ISequencerInbox.sol";
+
+import "../bridge/IBridge.sol";
+import "../bridge/IOutbox.sol";
+import "./RollupEventBridge.sol";
+import "./IRollupLogic.sol";
+
+struct Config {
+    uint64 confirmPeriodBlocks;
+    uint64 extraChallengeTimeBlocks;
+    address stakeToken;
+    uint256 baseStake;
+    bytes32 wasmModuleRoot;
+    address owner;
+    address loserStakeEscrow;
+    uint256 chainId;
+    ISequencerInbox.MaxTimeVariation sequencerInboxMaxTimeVariation;
+}
+
+struct ContractDependencies {
+    IBridge delayedBridge;
+    ISequencerInbox sequencerInbox;
+    IOutbox outbox;
+    RollupEventBridge rollupEventBridge;
+    IChallengeManager challengeManager;
+    IRollupAdmin rollupAdminLogic;
+    IRollupUser rollupUserLogic;
+}
+
+library RollupLib {
+    using GlobalStateLib for GlobalState;
+
+    struct ExecutionState {
+        GlobalState globalState;
+        MachineStatus machineStatus;
+    }
+
+    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
+                )
+            );
+    }
+
+    struct Assertion {
+        ExecutionState beforeState;
+        ExecutionState afterState;
+        uint64 numBlocks;
+    }
+
+    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
+    ) 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);
+    }
+
+    function challengeRootHash(
+        bytes32 execution,
+        uint256 proposedTime,
+        bytes32 wasmModuleRoot
+    ) 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()
+            );
+    }
+
+    function confirmHash(bytes32 blockHash, bytes32 sendRoot) internal pure returns (bytes32) {
+        return keccak256(abi.encodePacked(blockHash, sendRoot));
+    }
+
+    function nodeHash(
+        bool hasSibling,
+        bytes32 lastHash,
+        bytes32 assertionExecHash,
+        bytes32 inboxAcc
+    ) internal pure returns (bytes32) {
+        uint8 hasSiblingInt = hasSibling ? 1 : 0;
+        return keccak256(abi.encodePacked(hasSiblingInt, lastHash, assertionExecHash, inboxAcc));
+    }
+}