@arbitrum/nitro-contracts 1.0.0-beta.4 → 1.0.0-beta.7

package/src/precompiles/ArbRetryableTx.sol

@@ -55,6 +55,13 @@ interface ArbRetryableTx {
      */
     function cancel(bytes32 ticketId) external;
 
+    /**
+     * @notice Gets the redeemer of the current retryable redeem attempt.
+     * Returns the zero address if the current transaction is not a retryable redeem attempt.
+     * If this is an auto-redeem, returns the fee refund address of the retryable.
+     */
+    function getCurrentRedeemer() external view returns (address);
+
     /**
      * @notice Do not call. This method represents a retryable submission to aid explorers.
      * Calling it will always revert.
@@ -80,10 +87,15 @@ interface ArbRetryableTx {
         bytes32 indexed retryTxHash,
         uint64 indexed sequenceNum,
         uint64 donatedGas,
-        address gasDonor
+        address gasDonor,
+        uint256 maxRefund,
+        uint256 submissionFeeRefund
     );
     event Canceled(bytes32 indexed ticketId);
 
+    /// @dev DEPRECATED in favour of new RedeemScheduled event after the nitro upgrade
+    event Redeemed(bytes32 indexed userTxHash);
+
     error NoTicketWithID();
     error NotCallable();
 }

package/src/precompiles/ArbSys.sol

@@ -38,7 +38,7 @@ interface ArbSys {
      * @notice Returns 0 since Nitro has no concept of storage gas
      * @return int 0
      */
-    function getStorageGasAvailable() external returns (uint256);
+    function getStorageGasAvailable() external view returns (uint256);
 
     /**
      * @notice check if current call is coming from l1
@@ -107,11 +107,24 @@ interface ArbSys {
      * @notice creates a send txn from L2 to L1
      * @param position = (level << 192) + leaf = (0 << 192) + leaf = leaf
      */
-    event L2ToL1Transaction(
+    event L2ToL1Tx(
         address caller,
         address indexed destination,
         uint256 indexed hash,
         uint256 indexed position,
+        uint256 arbBlockNum,
+        uint256 ethBlockNum,
+        uint256 timestamp,
+        uint256 callvalue,
+        bytes data
+    );
+
+    /// @dev DEPRECATED in favour of the new L2ToL1Tx event above after the nitro upgrade
+    event L2ToL1Transaction(
+        address caller,
+        address indexed destination,
+        uint256 indexed uniqueId,
+        uint256 indexed batchNumber,
         uint256 indexInBatch,
         uint256 arbBlockNum,
         uint256 ethBlockNum,

package/src/precompiles/ArbosActs.sol

@@ -26,16 +26,23 @@ interface ArbosActs {
     /**
      * @notice ArbOS "calls" this when starting a block
      * @param l1BaseFee the L1 BaseFee
-     * @param l2BaseFeeLastBlock the L2 BaseFee in the last block's header
      * @param l1BlockNumber the L1 block number
      * @param timePassed number of seconds since the last block
      */
     function startBlock(
         uint256 l1BaseFee,
-        uint256 l2BaseFeeLastBlock,
         uint64 l1BlockNumber,
+        uint64 l2BlockNumber,
         uint64 timePassed
     ) external;
 
+    function batchPostingReport(
+        uint256 batchTimestamp,
+        address batchPosterAddress,
+        uint64 batchNumber,
+        uint64 batchDataGas,
+        uint256 l1BaseFeeWei
+    ) external;
+
     error CallerNotArbOS();
 }

package/src/rollup/BridgeCreator.sol

@@ -9,40 +9,40 @@ import "../bridge/SequencerInbox.sol";
 import "../bridge/ISequencerInbox.sol";
 import "../bridge/Inbox.sol";
 import "../bridge/Outbox.sol";
-import "./RollupEventBridge.sol";
+import "./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 delayedBridgeTemplate;
+    Bridge public bridgeTemplate;
     SequencerInbox public sequencerInboxTemplate;
     Inbox public inboxTemplate;
-    RollupEventBridge public rollupEventBridgeTemplate;
+    RollupEventInbox public rollupEventInboxTemplate;
     Outbox public outboxTemplate;
 
     event TemplatesUpdated();
 
     constructor() Ownable() {
-        delayedBridgeTemplate = new Bridge();
+        bridgeTemplate = new Bridge();
         sequencerInboxTemplate = new SequencerInbox();
         inboxTemplate = new Inbox();
-        rollupEventBridgeTemplate = new RollupEventBridge();
+        rollupEventInboxTemplate = new RollupEventInbox();
         outboxTemplate = new Outbox();
     }
 
     function updateTemplates(
-        address _delayedBridgeTemplate,
+        address _bridgeTemplate,
         address _sequencerInboxTemplate,
         address _inboxTemplate,
-        address _rollupEventBridgeTemplate,
+        address _rollupEventInboxTemplate,
         address _outboxTemplate
     ) external onlyOwner {
-        delayedBridgeTemplate = Bridge(_delayedBridgeTemplate);
+        bridgeTemplate = Bridge(_bridgeTemplate);
         sequencerInboxTemplate = SequencerInbox(_sequencerInboxTemplate);
         inboxTemplate = Inbox(_inboxTemplate);
-        rollupEventBridgeTemplate = RollupEventBridge(_rollupEventBridgeTemplate);
+        rollupEventInboxTemplate = RollupEventInbox(_rollupEventInboxTemplate);
         outboxTemplate = Outbox(_outboxTemplate);
 
         emit TemplatesUpdated();
@@ -50,10 +50,10 @@ contract BridgeCreator is Ownable {
 
     struct CreateBridgeFrame {
         ProxyAdmin admin;
-        Bridge delayedBridge;
+        Bridge bridge;
         SequencerInbox sequencerInbox;
         Inbox inbox;
-        RollupEventBridge rollupEventBridge;
+        RollupEventInbox rollupEventInbox;
         Outbox outbox;
     }
 
@@ -67,16 +67,14 @@ contract BridgeCreator is Ownable {
             Bridge,
             SequencerInbox,
             Inbox,
-            RollupEventBridge,
+            RollupEventInbox,
             Outbox
         )
     {
         CreateBridgeFrame memory frame;
         {
-            frame.delayedBridge = Bridge(
-                address(
-                    new TransparentUpgradeableProxy(address(delayedBridgeTemplate), adminProxy, "")
-                )
+            frame.bridge = Bridge(
+                address(new TransparentUpgradeableProxy(address(bridgeTemplate), adminProxy, ""))
             );
             frame.sequencerInbox = SequencerInbox(
                 address(
@@ -86,10 +84,10 @@ contract BridgeCreator is Ownable {
             frame.inbox = Inbox(
                 address(new TransparentUpgradeableProxy(address(inboxTemplate), adminProxy, ""))
             );
-            frame.rollupEventBridge = RollupEventBridge(
+            frame.rollupEventInbox = RollupEventInbox(
                 address(
                     new TransparentUpgradeableProxy(
-                        address(rollupEventBridgeTemplate),
+                        address(rollupEventInboxTemplate),
                         adminProxy,
                         ""
                     )
@@ -100,20 +98,17 @@ contract BridgeCreator is Ownable {
             );
         }
 
-        frame.delayedBridge.initialize();
-        frame.sequencerInbox.initialize(IBridge(frame.delayedBridge), rollup, maxTimeVariation);
-        frame.inbox.initialize(IBridge(frame.delayedBridge));
-        frame.rollupEventBridge.initialize(address(frame.delayedBridge), rollup);
-        frame.outbox.initialize(rollup, IBridge(frame.delayedBridge));
-
-        frame.delayedBridge.setInbox(address(frame.inbox), true);
-        frame.delayedBridge.transferOwnership(rollup);
+        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 (
-            frame.delayedBridge,
+            frame.bridge,
             frame.sequencerInbox,
             frame.inbox,
-            frame.rollupEventBridge,
+            frame.rollupEventInbox,
             frame.outbox
         );
     }

package/src/rollup/IRollupCore.sol

@@ -59,13 +59,13 @@ interface IRollupCore {
 
     function wasmModuleRoot() external view returns (bytes32);
 
-    function delayedBridge() external view returns (IBridge);
+    function bridge() external view returns (IBridge);
 
-    function sequencerBridge() external view returns (ISequencerInbox);
+    function sequencerInbox() external view returns (ISequencerInbox);
 
     function outbox() external view returns (IOutbox);
 
-    function rollupEventBridge() external view returns (IRollupEventBridge);
+    function rollupEventInbox() external view returns (IRollupEventInbox);
 
     function challengeManager() external view returns (IChallengeManager);
 

package/src/rollup/{IRollupEventBridge.sol → IRollupEventInbox.sol}

@@ -6,10 +6,10 @@ pragma solidity ^0.8.0;
 
 import "../bridge/IBridge.sol";
 
-interface IRollupEventBridge {
+interface IRollupEventInbox {
     function bridge() external view returns (IBridge);
 
-    function initialize(address _bridge, address _rollup) external;
+    function initialize(IBridge _bridge) external;
 
     function rollup() external view returns (address);
 

package/src/rollup/IRollupLogic.sol

@@ -8,8 +8,9 @@ import "./RollupLib.sol";
 import "./IRollupCore.sol";
 import "../bridge/ISequencerInbox.sol";
 import "../bridge/IOutbox.sol";
+import "../bridge/IOwnable.sol";
 
-interface IRollupUserAbs is IRollupCore {
+interface IRollupUserAbs is IRollupCore, IOwnable {
     /// @dev the user logic just validated configuration and shouldn't write to state during init
     /// this allows the admin logic to ensure consistency on parameters.
     function initialize(address stakeToken) external view;
@@ -52,7 +53,18 @@ interface IRollupUserAbs is IRollupCore {
 
     function requireUnresolved(uint256 nodeNum) external view;
 
-    function withdrawStakerFunds(address payable destination) external returns (uint256);
+    function withdrawStakerFunds() external returns (uint256);
+
+    function createChallenge(
+        address[2] calldata stakers,
+        uint64[2] calldata nodeNums,
+        MachineStatus[2] calldata machineStatuses,
+        GlobalState[2] calldata globalStates,
+        uint64 numBlocks,
+        bytes32 secondExecutionHash,
+        uint256[2] calldata proposedTimes,
+        bytes32[2] calldata wasmModuleRoots
+    ) external;
 }
 
 interface IRollupUser is IRollupUserAbs {
@@ -107,7 +119,7 @@ interface IRollupAdmin {
      * @param _inbox Inbox contract to add or remove
      * @param _enabled New status of inbox
      */
-    function setInbox(address _inbox, bool _enabled) external;
+    function setDelayedInbox(address _inbox, bool _enabled) external;
 
     /**
      * @notice Pause interaction with the rollup contract
@@ -166,21 +178,6 @@ interface IRollupAdmin {
      */
     function setStakeToken(address newStakeToken) external;
 
-    /**
-     * @notice Set max time variation from actual time for sequencer inbox
-     * @param maxTimeVariation the maximum time variation parameters
-     */
-    function setSequencerInboxMaxTimeVariation(
-        ISequencerInbox.MaxTimeVariation memory maxTimeVariation
-    ) external;
-
-    /**
-     * @notice Updates whether an address is authorized to be a batch poster at the sequencer inbox
-     * @param addr the address
-     * @param isBatchPoster if the specified address should be authorized as a batch poster
-     */
-    function setIsBatchPoster(address addr, bool isBatchPoster) external;
-
     /**
      * @notice Upgrades the implementation of a beacon controlled by the rollup
      * @param beacon address of beacon to be upgraded
@@ -212,4 +209,10 @@ interface IRollupAdmin {
      * @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;
 }

package/src/rollup/RollupAdminLogic.sol

@@ -21,16 +21,26 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, SecondaryLogicUUPSUpgrade
         onlyProxy
         initializer
     {
-        delayedBridge = connectedContracts.delayedBridge;
-        sequencerBridge = connectedContracts.sequencerInbox;
+        rollupDeploymentBlock = block.number;
+        bridge = connectedContracts.bridge;
+        sequencerInbox = connectedContracts.sequencerInbox;
+        connectedContracts.bridge.setDelayedInbox(address(connectedContracts.inbox), true);
+        connectedContracts.bridge.setSequencerInbox(address(connectedContracts.sequencerInbox));
+
+        inbox = connectedContracts.inbox;
         outbox = connectedContracts.outbox;
-        delayedBridge.setOutbox(address(connectedContracts.outbox), true);
-        rollupEventBridge = connectedContracts.rollupEventBridge;
-        delayedBridge.setInbox(address(connectedContracts.rollupEventBridge), true);
+        connectedContracts.bridge.setOutbox(address(connectedContracts.outbox), true);
+        rollupEventInbox = connectedContracts.rollupEventInbox;
+        connectedContracts.bridge.setDelayedInbox(
+            address(connectedContracts.rollupEventInbox),
+            true
+        );
 
-        rollupEventBridge.rollupInitialized(config.chainId);
-        sequencerBridge.addSequencerL2Batch(0, "", 1, IGasRefunder(address(0)));
+        connectedContracts.rollupEventInbox.rollupInitialized(config.chainId);
+        connectedContracts.sequencerInbox.addSequencerL2Batch(0, "", 1, IGasRefunder(address(0)));
 
+        validatorUtils = connectedContracts.validatorUtils;
+        validatorWalletCreator = connectedContracts.validatorWalletCreator;
         challengeManager = connectedContracts.challengeManager;
 
         Node memory node = createInitialNode();
@@ -53,8 +63,6 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, SecondaryLogicUUPSUpgrade
 
         stakeToken = config.stakeToken;
 
-        sequencerBridge.setMaxTimeVariation(config.sequencerInboxMaxTimeVariation);
-
         emit RollupInitialized(config.wasmModuleRoot, config.chainId);
     }
 
@@ -86,7 +94,7 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, SecondaryLogicUUPSUpgrade
      */
     function setOutbox(IOutbox _outbox) external override {
         outbox = _outbox;
-        delayedBridge.setOutbox(address(_outbox), true);
+        bridge.setOutbox(address(_outbox), true);
         emit OwnerFunctionCalled(0);
     }
 
@@ -96,7 +104,7 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, SecondaryLogicUUPSUpgrade
      */
     function removeOldOutbox(address _outbox) external override {
         require(_outbox != address(outbox), "CUR_OUTBOX");
-        delayedBridge.setOutbox(_outbox, false);
+        bridge.setOutbox(_outbox, false);
         emit OwnerFunctionCalled(1);
     }
 
@@ -105,8 +113,8 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, SecondaryLogicUUPSUpgrade
      * @param _inbox Inbox contract to add or remove
      * @param _enabled New status of inbox
      */
-    function setInbox(address _inbox, bool _enabled) external override {
-        delayedBridge.setInbox(address(_inbox), _enabled);
+    function setDelayedInbox(address _inbox, bool _enabled) external override {
+        bridge.setDelayedInbox(address(_inbox), _enabled);
         emit OwnerFunctionCalled(2);
     }
 
@@ -224,27 +232,6 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, SecondaryLogicUUPSUpgrade
         emit OwnerFunctionCalled(13);
     }
 
-    /**
-     * @notice Set max delay for sequencer inbox
-     * @param maxTimeVariation the maximum time variation parameters
-     */
-    function setSequencerInboxMaxTimeVariation(
-        ISequencerInbox.MaxTimeVariation calldata maxTimeVariation
-    ) external override {
-        sequencerBridge.setMaxTimeVariation(maxTimeVariation);
-        emit OwnerFunctionCalled(14);
-    }
-
-    /**
-     * @notice Updates whether an address is authorized to be a batch poster at the sequencer inbox
-     * @param addr the address
-     * @param isBatchPoster if the specified address should be authorized as a batch poster
-     */
-    function setIsBatchPoster(address addr, bool isBatchPoster) external override {
-        ISequencerInbox(sequencerBridge).setIsBatchPoster(addr, isBatchPoster);
-        emit OwnerFunctionCalled(19);
-    }
-
     /**
      * @notice Upgrades the implementation of a beacon controlled by the rollup
      * @param beacon address of beacon to be upgraded
@@ -319,4 +306,13 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, SecondaryLogicUUPSUpgrade
         wasmModuleRoot = newWasmModuleRoot;
         emit OwnerFunctionCalled(26);
     }
+
+    /**
+     * @notice set a new sequencer inbox contract
+     * @param _sequencerInbox new address of sequencer inbox
+     */
+    function setSequencerInbox(address _sequencerInbox) external override {
+        bridge.setSequencerInbox(_sequencerInbox);
+        emit OwnerFunctionCalled(27);
+    }
 }

package/src/rollup/RollupCore.sol

@@ -9,7 +9,7 @@ import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
 import "./Node.sol";
 import "./IRollupCore.sol";
 import "./RollupLib.sol";
-import "./IRollupEventBridge.sol";
+import "./IRollupEventInbox.sol";
 import "./IRollupCore.sol";
 
 import "../challenge/IChallengeManager.sol";
@@ -31,11 +31,17 @@ abstract contract RollupCore is IRollupCore, PausableUpgradeable {
     uint256 public baseStake;
     bytes32 public wasmModuleRoot;
 
-    IBridge public delayedBridge;
-    ISequencerInbox public sequencerBridge;
+    IInbox public inbox;
+    IBridge public bridge;
     IOutbox public outbox;
-    IRollupEventBridge public rollupEventBridge;
+    ISequencerInbox public sequencerInbox;
+    IRollupEventInbox public rollupEventInbox;
     IChallengeManager public override challengeManager;
+
+    // misc useful contracts when interacting with the rollup
+    address public validatorUtils;
+    address public validatorWalletCreator;
+
     // when a staker loses a challenge, half of their funds get escrowed in this address
     address public loserStakeEscrow;
     address public stakeToken;
@@ -63,6 +69,7 @@ abstract contract RollupCore is IRollupCore, PausableUpgradeable {
 
     mapping(address => uint256) private _withdrawableFunds;
     uint256 public totalWithdrawableFunds;
+    uint256 public rollupDeploymentBlock;
 
     // The node number of the initial node
     uint64 internal constant GENESIS_NODE = 0;
@@ -529,7 +536,7 @@ abstract contract RollupCore is IRollupCore, PausableUpgradeable {
         {
             // validate data
             memoryFrame.prevNode = getNode(prevNodeNum);
-            memoryFrame.currentInboxSize = sequencerBridge.batchCount();
+            memoryFrame.currentInboxSize = bridge.sequencerMessageCount();
 
             // Make sure the previous state is correct against the node being built on
             require(
@@ -560,7 +567,7 @@ abstract contract RollupCore is IRollupCore, PausableUpgradeable {
             require(afterInboxCount <= memoryFrame.currentInboxSize, "INBOX_PAST_END");
             // This gives replay protection against the state of the inbox
             if (afterInboxCount > 0) {
-                memoryFrame.sequencerBatchAcc = sequencerBridge.inboxAccs(afterInboxCount - 1);
+                memoryFrame.sequencerBatchAcc = bridge.sequencerInboxAccs(afterInboxCount - 1);
             }
         }
 
@@ -582,7 +589,8 @@ abstract contract RollupCore is IRollupCore, PausableUpgradeable {
                 memoryFrame.hasSibling,
                 memoryFrame.lastHash,
                 memoryFrame.executionHash,
-                memoryFrame.sequencerBatchAcc
+                memoryFrame.sequencerBatchAcc,
+                wasmModuleRoot
             );
             require(newNodeHash == expectedNodeHash, "UNEXPECTED_NODE_HASH");
 

package/src/rollup/RollupCreator.sol

@@ -18,7 +18,7 @@ contract RollupCreator is Ownable {
         address inboxAddress,
         address adminProxy,
         address sequencerInbox,
-        address delayedBridge
+        address bridge
     );
     event TemplatesUpdated();
 
@@ -28,6 +28,9 @@ contract RollupCreator is Ownable {
     IRollupAdmin public rollupAdminLogic;
     IRollupUser public rollupUserLogic;
 
+    address public validatorUtils;
+    address public validatorWalletCreator;
+
     constructor() Ownable() {}
 
     function setTemplates(
@@ -35,22 +38,26 @@ contract RollupCreator is Ownable {
         IOneStepProofEntry _osp,
         IChallengeManager _challengeManagerLogic,
         IRollupAdmin _rollupAdminLogic,
-        IRollupUser _rollupUserLogic
+        IRollupUser _rollupUserLogic,
+        address _validatorUtils,
+        address _validatorWalletCreator
     ) external onlyOwner {
         bridgeCreator = _bridgeCreator;
         osp = _osp;
         challengeManagerTemplate = _challengeManagerLogic;
         rollupAdminLogic = _rollupAdminLogic;
         rollupUserLogic = _rollupUserLogic;
+        validatorUtils = _validatorUtils;
+        validatorWalletCreator = _validatorWalletCreator;
         emit TemplatesUpdated();
     }
 
     struct CreateRollupFrame {
         ProxyAdmin admin;
-        IBridge delayedBridge;
+        IBridge bridge;
         ISequencerInbox sequencerInbox;
         IInbox inbox;
-        IRollupEventBridge rollupEventBridge;
+        IRollupEventInbox rollupEventInbox;
         IOutbox outbox;
         ArbitrumProxy rollup;
     }
@@ -68,10 +75,10 @@ contract RollupCreator is Ownable {
         frame.admin = new ProxyAdmin();
 
         (
-            frame.delayedBridge,
+            frame.bridge,
             frame.sequencerInbox,
             frame.inbox,
-            frame.rollupEventBridge,
+            frame.rollupEventInbox,
             frame.outbox
         ) = bridgeCreator.createBridge(
             address(frame.admin),
@@ -93,20 +100,23 @@ contract RollupCreator is Ownable {
         challengeManager.initialize(
             IChallengeResultReceiver(expectedRollupAddr),
             frame.sequencerInbox,
-            frame.delayedBridge,
+            frame.bridge,
             osp
         );
 
         frame.rollup = new ArbitrumProxy(
             config,
             ContractDependencies({
-                delayedBridge: frame.delayedBridge,
+                bridge: frame.bridge,
                 sequencerInbox: frame.sequencerInbox,
+                inbox: frame.inbox,
                 outbox: frame.outbox,
-                rollupEventBridge: frame.rollupEventBridge,
+                rollupEventInbox: frame.rollupEventInbox,
                 challengeManager: challengeManager,
                 rollupAdminLogic: rollupAdminLogic,
-                rollupUserLogic: rollupUserLogic
+                rollupUserLogic: rollupUserLogic,
+                validatorUtils: validatorUtils,
+                validatorWalletCreator: validatorWalletCreator
             })
         );
         require(address(frame.rollup) == expectedRollupAddr, "WRONG_ROLLUP_ADDR");
@@ -116,7 +126,7 @@ contract RollupCreator is Ownable {
             address(frame.inbox),
             address(frame.admin),
             address(frame.sequencerInbox),
-            address(frame.delayedBridge)
+            address(frame.bridge)
         );
         return address(frame.rollup);
     }

package/src/rollup/{RollupEventBridge.sol → RollupEventInbox.sol}

@@ -4,36 +4,36 @@
 
 pragma solidity ^0.8.0;
 
-import "./IRollupEventBridge.sol";
+import "./IRollupEventInbox.sol";
 import "../bridge/IBridge.sol";
-import "../bridge/IMessageProvider.sol";
+import "../bridge/IDelayedMessageProvider.sol";
 import "../libraries/DelegateCallAware.sol";
 import {INITIALIZATION_MSG_TYPE} from "../libraries/MessageTypes.sol";
 
 /**
  * @title The inbox for rollup protocol events
  */
-contract RollupEventBridge is IRollupEventBridge, IMessageProvider, DelegateCallAware {
+contract RollupEventInbox is IRollupEventInbox, IDelayedMessageProvider, 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;
+    IBridge public override bridge;
+    address public override 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 initialize(IBridge _bridge) external override onlyDelegated {
+        require(address(bridge) == address(0), "ALREADY_INIT");
+        bridge = _bridge;
+        rollup = address(_bridge.rollup());
     }
 
-    function rollupInitialized(uint256 chainId) external onlyRollup {
+    function rollupInitialized(uint256 chainId) external override onlyRollup {
         bytes memory initMsg = abi.encodePacked(chainId);
         uint256 num = bridge.enqueueDelayedMessage(
             INITIALIZATION_MSG_TYPE,