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

package/README.md

@@ -0,0 +1,15 @@
+# Arbitrum Nitro Contracts
+
+This is the package with the smart contract code that powers Arbitrum Nitro.
+It includes the rollup and fraud proof smart contracts, as well as interfaces for interacting with precompiles.
+
+For more information see https://developer.arbitrum.io/docs/public_nitro_devnet
+
+
+Compile the contracts locally by running
+```bash
+git clone https://github.com/offchainlabs/nitro
+cd nitro/contracts
+yarn install
+yarn build
+```

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "@arbitrum/nitro-contracts",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.4",
   "description": "Layer 2 precompiles and rollup for Arbitrum Nitro",
-  "main": "index.js",
   "author": "Offchain Labs, Inc.",
-  "license": "UNLICENSED",
+  "license": "BUSL-1.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/offchainlabs/nitro.git",
     "directory": "contracts"
   },
+  "files": [
+    "src/",
+    "scripts/build.bash",
+    "hardhat.prod-config.js"
+  ],
   "bugs": {
     "url": "https://github.com/offchainlabs/nitro/issues"
   },
@@ -21,29 +25,29 @@
   },
   "dependencies": {
     "@openzeppelin/contracts": "4.5.0",
-    "@openzeppelin/contracts-upgradeable": "4.5.1",
+    "@openzeppelin/contracts-upgradeable": "4.5.2",
     "hardhat": "^2.6.6"
   },
   "private": false,
   "devDependencies": {
     "@nomiclabs/hardhat-ethers": "npm:hardhat-deploy-ethers@^0.3.0-beta.13",
     "@nomiclabs/hardhat-waffle": "^2.0.1",
-    "@typechain/ethers-v5": "^9.0.0",
-    "@typechain/hardhat": "^4.0.0",
+    "@typechain/ethers-v5": "^10.0.0",
+    "@typechain/hardhat": "^6.0.0",
     "@types/chai": "^4.3.0",
     "@types/mocha": "^9.0.0",
     "@types/node": "^17.0.5",
     "chai": "^4.3.4",
     "ethereum-waffle": "^3.4.0",
     "ethers": "^5.5.2",
-    "hardhat-deploy": "^0.10.5",
+    "hardhat-deploy": "^0.11.4",
     "prettier": "^2.5.1",
     "prettier-plugin-solidity": "^1.0.0-beta.19",
     "solhint": "^3.3.7",
     "solhint-plugin-prettier": "^0.0.5",
     "solidity-coverage": "^0.7.20",
     "ts-node": "^10.4.0",
-    "typechain": "^7.0.0",
+    "typechain": "^8.0.0",
     "typescript": "^4.5.4"
   }
 }

package/src/bridge/IInbox.sol

@@ -17,6 +17,12 @@ error AlreadyUnpaused();
 /// @dev The contract is paused
 error Paused();
 
+/// @dev msg.value sent to the inbox isn't high enough
+error InsufficientValue(uint256 expected, uint256 actual);
+
+/// @dev submission cost provided isn't enough to create retryable ticket
+error InsufficientSubmissionCost(uint256 expected, uint256 actual);
+
 interface IInbox is IMessageProvider {
     function sendL2Message(bytes calldata messageData) external returns (uint256);
 
@@ -74,6 +80,9 @@ interface IInbox is IMessageProvider {
         bytes calldata data
     ) external payable returns (uint256);
 
+    function depositEth() external payable returns (uint256);
+
+    /// @notice deprecated in favour of depositEth with no parameters
     function depositEth(uint256 maxSubmissionCost) external payable returns (uint256);
 
     function bridge() external view returns (IBridge);

package/src/bridge/Inbox.sol

@@ -14,14 +14,15 @@ import {
     L2_MSG,
     L1MessageType_L2FundedByL1,
     L1MessageType_submitRetryableTx,
+    L1MessageType_ethDeposit,
     L2MessageType_unsignedEOATx,
     L2MessageType_unsignedContractTx
 } from "../libraries/MessageTypes.sol";
 import {MAX_DATA_SIZE} from "../libraries/Constants.sol";
 
+import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
-import "./Bridge.sol";
 
 /**
  * @title Inbox for user and contract originated messages
@@ -33,7 +34,7 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
 
     modifier onlyOwner() {
         // whoevever owns the Bridge, also owns the Inbox. this is usually the rollup contract
-        address bridgeOwner = Bridge(address(bridge)).owner();
+        address bridgeOwner = OwnableUpgradeable(address(bridge)).owner();
         if (msg.sender != bridgeOwner) revert NotOwner(msg.sender, bridgeOwner);
         _;
     }
@@ -96,11 +97,7 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
         whenNotPaused
         returns (uint256)
     {
-        if (messageData.length > MAX_DATA_SIZE)
-            revert DataTooLarge(messageData.length, MAX_DATA_SIZE);
-        uint256 msgNum = deliverToBridge(L2_MSG, msg.sender, keccak256(messageData));
-        emit InboxMessageDelivered(msgNum, messageData);
-        return msgNum;
+        return _deliverMessage(L2_MSG, msg.sender, messageData);
     }
 
     function sendL1FundedUnsignedTransaction(
@@ -209,20 +206,11 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
     }
 
     /// @notice deposit eth from L1 to L2
+    /// @dev this does not trigger the fallback function when receiving in the L2 side.
+    /// Look into retryable tickets if you are interested in this functionality.
     /// @dev this function should not be called inside contract constructors
-    function depositEth(uint256 maxSubmissionCost)
-        external
-        payable
-        virtual
-        override
-        whenNotPaused
-        returns (uint256)
-    {
+    function depositEth() public payable override whenNotPaused returns (uint256) {
         address sender = msg.sender;
-        address destinationAddress = msg.sender;
-
-        uint256 submissionFee = calculateRetryableSubmissionFee(0, block.basefee);
-        require(maxSubmissionCost >= submissionFee, "insufficient submission fee");
 
         // solhint-disable-next-line avoid-tx-origin
         if (!AddressUpgradeable.isContract(sender) && tx.origin == msg.sender) {
@@ -233,31 +221,21 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
             // have the L1 sender address mapped.
             // Here we preemptively reverse the mapping for EOAs so deposits work as expected
             sender = AddressAliasHelper.undoL1ToL2Alias(sender);
-        } else {
-            destinationAddress = AddressAliasHelper.applyL1ToL2Alias(destinationAddress);
         }
 
         return
             _deliverMessage(
-                L1MessageType_submitRetryableTx,
-                sender,
-                abi.encodePacked(
-                    // the beneficiary and other refund addresses don't get rewritten by arb-os
-                    // so we use the original msg.sender value
-                    uint256(uint160(bytes20(destinationAddress))),
-                    uint256(0),
-                    msg.value,
-                    maxSubmissionCost,
-                    uint256(uint160(bytes20(destinationAddress))),
-                    uint256(uint160(bytes20(destinationAddress))),
-                    uint256(0),
-                    uint256(0),
-                    uint256(0),
-                    ""
-                )
+                L1MessageType_ethDeposit,
+                sender, // arb-os will add the alias to this value
+                abi.encodePacked(msg.value)
             );
     }
 
+    /// @notice deprecated in favour of depositEth with no parameters
+    function depositEth(uint256) external payable virtual override whenNotPaused returns (uint256) {
+        return depositEth();
+    }
+
     /**
      * @notice deprecated in favour of unsafeCreateRetryableTicket
      * @dev deprecated in favour of unsafeCreateRetryableTicket
@@ -318,7 +296,8 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
         bytes calldata data
     ) external payable virtual override whenNotPaused returns (uint256) {
         // ensure the user's deposit alone will make submission succeed
-        require(msg.value >= maxSubmissionCost + l2CallValue, "insufficient value");
+        if (msg.value < maxSubmissionCost + l2CallValue)
+            revert InsufficientValue(maxSubmissionCost + l2CallValue, msg.value);
 
         // if a refund address is a contract, we apply the alias to it
         // so that it can access its funds on the L2
@@ -371,7 +350,8 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
         bytes calldata data
     ) public payable virtual override whenNotPaused returns (uint256) {
         uint256 submissionFee = calculateRetryableSubmissionFee(data.length, block.basefee);
-        require(maxSubmissionCost >= submissionFee, "insufficient submission fee");
+        if (maxSubmissionCost < submissionFee)
+            revert InsufficientSubmissionCost(submissionFee, maxSubmissionCost);
 
         return
             _deliverMessage(

package/src/libraries/AdminFallbackProxy.sol

@@ -11,8 +11,6 @@ import "@openzeppelin/contracts/utils/StorageSlot.sol";
 
 /// @notice An extension to OZ's ERC1967Upgrade implementation to support two logic contracts
 abstract contract DoubleLogicERC1967Upgrade is ERC1967Upgrade {
-    using Address for address;
-
     // This is the keccak-256 hash of "eip1967.proxy.implementation.secondary" subtracted by 1
     bytes32 internal constant _IMPLEMENTATION_SECONDARY_SLOT =
         0x2b1dbce74324248c222f0ec2d5ed7bd323cfc425b336f0253c5ccfda7265546d;
@@ -133,12 +131,14 @@ contract AdminFallbackProxy is Proxy, DoubleLogicERC1967Upgrade {
     function _implementation() internal view override returns (address) {
         require(msg.data.length >= 4, "NO_FUNC_SIG");
         // if the sender is the proxy's admin, delegate to admin logic
-        // if the admin is disabled (set to addr zero), all calls will be forwarded to user logic
+        // if the admin is disabled, all calls will be forwarded to user logic
+        // admin affordances can be disabled by setting to address(1) since
+        // `ERC1697._setAdmin()` doesn't allow address(0) to be set
         address target = _getAdmin() != msg.sender
             ? DoubleLogicERC1967Upgrade._getSecondaryImplementation()
             : ERC1967Upgrade._getImplementation();
-        // implementation setters already do an existence check
-        // require(target.isContract(), "TARGET_NOT_CONTRACT");
+        // implementation setters do an existence check, but we protect against selfdestructs this way
+        require(Address.isContract(target), "TARGET_NOT_CONTRACT");
         return target;
     }
 

package/src/libraries/MessageTypes.sol

@@ -7,6 +7,7 @@ pragma solidity ^0.8.4;
 uint8 constant L2_MSG = 3;
 uint8 constant L1MessageType_L2FundedByL1 = 7;
 uint8 constant L1MessageType_submitRetryableTx = 9;
+uint8 constant L1MessageType_ethDeposit = 12;
 uint8 constant L2MessageType_unsignedEOATx = 0;
 uint8 constant L2MessageType_unsignedContractTx = 1;
 

package/src/mocks/InboxStub.sol

@@ -125,6 +125,10 @@ contract InboxStub is IInbox {
         revert("NOT_IMPLEMENTED");
     }
 
+    function depositEth() external payable override returns (uint256) {
+        revert("NOT_IMPLEMENTED");
+    }
+
     function depositEth(uint256) external payable override returns (uint256) {
         revert("NOT_IMPLEMENTED");
     }

package/src/mocks/Simple.sol

@@ -0,0 +1,30 @@
+// 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;
+
+contract Simple {
+    uint64 public counter;
+
+    event CounterEvent(uint64 count);
+    event NullEvent();
+
+    function increment() external {
+        counter++;
+    }
+
+    function incrementEmit() external {
+        counter++;
+        emit CounterEvent(counter);
+    }
+
+    function emitNullEvent() external {
+        emit NullEvent();
+    }
+
+    function checkBlockHashes() external view returns (uint256) {
+        require(blockhash(block.number - 1) != blockhash(block.number - 2), "SAME_BLOCK_HASH");
+        return block.number;
+    }
+}

package/src/node-interface/NodeInterface.sol

@@ -9,7 +9,6 @@ pragma solidity >=0.4.21 <0.9.0;
  *  0x00000000000000000000000000000000000000C8
  *  This is a cute trick to allow an Arbitrum node to provide data without us having to implement additional RPCs
  */
-
 interface NodeInterface {
     /**
      * @notice Estimate the cost of putting a message in the L2 inbox that is reexecuted
@@ -47,4 +46,22 @@ interface NodeInterface {
             bytes32 root,
             bytes32[] memory proof
         );
+
+    /**
+     * @notice Finds the L1 batch containing a requested L2 block, reverting if none does
+     * Throws if block doesn't exist, or if block number is 0
+     * @param blockNum The L2 block being queried
+     * @return batch The L1 block containing the requested L2 block
+     */
+    function findBatchContainingBlock(uint64 blockNum) external view returns (uint64 batch);
+
+    /**
+     * @notice Gets the number of L1 confirmations of the sequencer batch producing the requested L2 block
+     * This gets the number of L1 confirmations for the input message producing the L2 block,
+     * which happens well before the L1 rollup contract confirms the L2 block.
+     * Throws if block doesnt exist in the L2 chain.
+     * @param blockHash The hash of the L2 block being queried
+     * @return confirmations The number of L1 confirmations the sequencer batch has. Returns 0 if block not yet included in an L1 batch.
+     */
+    function getL1Confirmations(bytes32 blockHash) external view returns (uint64 confirmations);
 }

package/src/node-interface/NodeInterfaceDebug.sol

@@ -0,0 +1,30 @@
+// 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.4.21 <0.9.0;
+
+/** @title An extension to NodeInterface not meant for public consumption. Do not call.
+ *  @notice This contract doesn't exist on-chain. Instead it is a virtual interface accessible at 0xc9.
+ *  These methods add additional debugging and network monitoring instruments not intended for end users and
+ *  as such may change without notice.
+ */
+
+interface NodeInterfaceDebug {
+    struct RetryableInfo {
+        uint64 timeout;
+        address from;
+        address to;
+        uint256 value;
+        address beneficiary;
+        uint64 tries;
+        bytes data;
+    }
+
+    /**
+     * @notice gets a retryable
+     * @param ticket the retryable's id
+     * @return retryable the serialized retryable
+     */
+    function getRetryable(bytes32 ticket) external view returns (RetryableInfo memory retryable);
+}

package/src/osp/OneStepProver0.sol

@@ -309,6 +309,18 @@ contract OneStepProver0 is IOneStepProver {
         mach.functionPc = 0;
     }
 
+    function executeArbitraryJump(
+        Machine memory mach,
+        Module memory,
+        Instruction calldata inst,
+        bytes calldata
+    ) internal pure {
+        // Jump to target
+        uint32 pc = uint32(inst.argumentData);
+        require(pc == inst.argumentData, "BAD_CALL_DATA");
+        mach.functionPc = pc;
+    }
+
     function executeArbitraryJumpIf(
         Machine memory mach,
         Module memory,
@@ -527,6 +539,8 @@ contract OneStepProver0 is IOneStepProver {
             impl = executeEndBlock;
         } else if (opcode == Instructions.END_BLOCK_IF) {
             impl = executeEndBlockIf;
+        } else if (opcode == Instructions.ARBITRARY_JUMP) {
+            impl = executeArbitraryJump;
         } else if (opcode == Instructions.ARBITRARY_JUMP_IF) {
             impl = executeArbitraryJumpIf;
         } else if (opcode == Instructions.LOCAL_GET) {

package/src/osp/OneStepProverMath.sol

@@ -283,7 +283,7 @@ contract OneStepProverMath is IOneStepProver {
                 res = a >> (b % 32);
             } else if (opcodeOffset == 11) {
                 // shr_s
-                res = uint32(int32(a) >> b);
+                res = uint32(int32(a) >> (b % 32));
             } else if (opcodeOffset == 13) {
                 // rotl
                 res = rotl32(a, b);
@@ -333,7 +333,7 @@ contract OneStepProverMath is IOneStepProver {
                 res = a >> (b % 64);
             } else if (opcodeOffset == 11) {
                 // shr_s
-                res = uint64(int64(a) >> b);
+                res = uint64(int64(a) >> (b % 64));
             } else if (opcodeOffset == 13) {
                 // rotl
                 res = rotl64(a, b);

package/src/precompiles/ArbOwner.sol

@@ -60,6 +60,9 @@ interface ArbOwner {
     /// @notice Set the network fee collector
     function setNetworkFeeAccount(address newNetworkFeeAccount) external;
 
+    /// @notice Upgrades ArbOS to the requested version at the requested timestamp
+    function scheduleArbOSUpgrade(uint64 newVersion, uint64 timestamp) external;
+
     // Emitted when a successful call is made to this precompile
     event OwnerActs(bytes4 indexed method, address indexed owner, bytes data);
 }

package/src/rollup/IRollupCore.sol

@@ -7,8 +7,6 @@ pragma solidity ^0.8.0;
 import "./Node.sol";
 import "./RollupLib.sol";
 
-import "../osp/IOneStepProofEntry.sol";
-
 interface IRollupCore {
     struct Staker {
         uint256 amountStaked;
@@ -51,8 +49,34 @@ interface IRollupCore {
         uint256 finalBalance
     );
 
+    function confirmPeriodBlocks() external view returns (uint64);
+
+    function extraChallengeTimeBlocks() external view returns (uint64);
+
+    function chainId() external view returns (uint256);
+
+    function baseStake() external view returns (uint256);
+
+    function wasmModuleRoot() external view returns (bytes32);
+
+    function delayedBridge() external view returns (IBridge);
+
+    function sequencerBridge() external view returns (ISequencerInbox);
+
+    function outbox() external view returns (IOutbox);
+
+    function rollupEventBridge() external view returns (IRollupEventBridge);
+
     function challengeManager() external view returns (IChallengeManager);
 
+    function loserStakeEscrow() external view returns (address);
+
+    function stakeToken() external view returns (address);
+
+    function minimumAssertionPeriod() external view returns (uint256);
+
+    function isValidator(address) external view returns (bool);
+
     /**
      * @notice Get the Node for the given index.
      */

package/src/rollup/IRollupEventBridge.sol

@@ -0,0 +1,17 @@
+// 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/IBridge.sol";
+
+interface IRollupEventBridge {
+    function bridge() external view returns (IBridge);
+
+    function initialize(address _bridge, address _rollup) external;
+
+    function rollup() external view returns (address);
+
+    function rollupInitialized(uint256 chainId) external;
+}

package/src/rollup/IRollupLogic.sol

@@ -16,15 +16,43 @@ interface IRollupUserAbs is IRollupCore {
 
     function isERC20Enabled() external view returns (bool);
 
+    function rejectNextNode(address stakerAddress) external;
+
+    function confirmNextNode(bytes32 blockHash, bytes32 sendRoot) external;
+
+    function stakeOnExistingNode(uint64 nodeNum, bytes32 nodeHash) external;
+
+    function stakeOnNewNode(
+        RollupLib.Assertion memory assertion,
+        bytes32 expectedNodeHash,
+        uint256 prevNodeInboxMaxCount
+    ) external;
+
     function returnOldDeposit(address stakerAddress) external;
 
-    function requireUnresolved(uint256 nodeNum) external view;
+    function reduceDeposit(uint256 target) external;
 
-    function requireUnresolvedExists() external view;
+    function removeZombie(uint256 zombieNum, uint256 maxNodes) external;
+
+    function removeOldZombies(uint256 startIndex) external;
+
+    function requiredStake(
+        uint256 blockNumber,
+        uint64 firstUnresolvedNodeNum,
+        uint64 latestCreatedNode
+    ) external view returns (uint256);
+
+    function currentRequiredStake() external view returns (uint256);
 
     function countStakedZombies(uint64 nodeNum) external view returns (uint256);
 
     function countZombiesStakedOnChildren(uint64 nodeNum) external view returns (uint256);
+
+    function requireUnresolvedExists() external view;
+
+    function requireUnresolved(uint256 nodeNum) external view;
+
+    function withdrawStakerFunds(address payable destination) external returns (uint256);
 }
 
 interface IRollupUser is IRollupUserAbs {
@@ -35,6 +63,8 @@ interface IRollupUser is IRollupUserAbs {
         bytes32 expectedNodeHash,
         uint256 prevNodeInboxMaxCount
     ) external payable;
+
+    function addToDeposit(address stakerAddress) external payable;
 }
 
 interface IRollupUserERC20 is IRollupUserAbs {
@@ -50,6 +80,8 @@ interface IRollupUserERC20 is IRollupUserAbs {
         bytes32 expectedNodeHash,
         uint256 prevNodeInboxMaxCount
     ) external;
+
+    function addToDeposit(address stakerAddress, uint256 tokenAmount) external;
 }
 
 interface IRollupAdmin {

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 "./RollupEventBridge.sol";
+import "./IRollupEventBridge.sol";
 import "./IRollupCore.sol";
 
 import "../challenge/IChallengeManager.sol";
@@ -34,7 +34,7 @@ abstract contract RollupCore is IRollupCore, PausableUpgradeable {
     IBridge public delayedBridge;
     ISequencerInbox public sequencerBridge;
     IOutbox public outbox;
-    RollupEventBridge public rollupEventBridge;
+    IRollupEventBridge public rollupEventBridge;
     IChallengeManager public override challengeManager;
     // when a staker loses a challenge, half of their funds get escrowed in this address
     address public loserStakeEscrow;

package/src/rollup/RollupCreator.sol

@@ -4,11 +4,6 @@
 
 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";
@@ -16,11 +11,6 @@ import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.so
 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(
@@ -57,11 +47,11 @@ contract RollupCreator is Ownable {
 
     struct CreateRollupFrame {
         ProxyAdmin admin;
-        Bridge delayedBridge;
-        SequencerInbox sequencerInbox;
-        Inbox inbox;
-        RollupEventBridge rollupEventBridge;
-        Outbox outbox;
+        IBridge delayedBridge;
+        ISequencerInbox sequencerInbox;
+        IInbox inbox;
+        IRollupEventBridge rollupEventBridge;
+        IOutbox outbox;
         ArbitrumProxy rollup;
     }
 

package/src/rollup/RollupEventBridge.sol

@@ -4,8 +4,7 @@
 
 pragma solidity ^0.8.0;
 
-import "./IRollupLogic.sol";
-
+import "./IRollupEventBridge.sol";
 import "../bridge/IBridge.sol";
 import "../bridge/IMessageProvider.sol";
 import "../libraries/DelegateCallAware.sol";
@@ -14,7 +13,7 @@ import {INITIALIZATION_MSG_TYPE} from "../libraries/MessageTypes.sol";
 /**
  * @title The inbox for rollup protocol events
  */
-contract RollupEventBridge is IMessageProvider, DelegateCallAware {
+contract RollupEventBridge is IRollupEventBridge, IMessageProvider, DelegateCallAware {
     uint8 internal constant CREATE_NODE_EVENT = 0;
     uint8 internal constant CONFIRM_NODE_EVENT = 1;
     uint8 internal constant REJECT_NODE_EVENT = 2;

package/src/rollup/RollupLib.sol

@@ -11,7 +11,7 @@ import "../bridge/ISequencerInbox.sol";
 
 import "../bridge/IBridge.sol";
 import "../bridge/IOutbox.sol";
-import "./RollupEventBridge.sol";
+import "./IRollupEventBridge.sol";
 import "./IRollupLogic.sol";
 
 struct Config {
@@ -30,7 +30,7 @@ struct ContractDependencies {
     IBridge delayedBridge;
     ISequencerInbox sequencerInbox;
     IOutbox outbox;
-    RollupEventBridge rollupEventBridge;
+    IRollupEventBridge rollupEventBridge;
     IChallengeManager challengeManager;
     IRollupAdmin rollupAdminLogic;
     IRollupUser rollupUserLogic;

package/src/rollup/RollupUserLogic.sol

@@ -564,8 +564,6 @@ abstract contract AbsRollupUserLogic is
         require(isStaked(stakerAddress), "NOT_STAKED");
         require(currentChallenge(stakerAddress) == NO_CHAL_INDEX, "IN_CHAL");
     }
-
-    function withdrawStakerFunds(address payable destination) external virtual returns (uint256);
 }
 
 contract RollupUserLogic is AbsRollupUserLogic, IRollupUser {
@@ -605,7 +603,13 @@ contract RollupUserLogic is AbsRollupUserLogic, IRollupUser {
      * @notice Increase the amount staked eth for the given staker
      * @param stakerAddress Address of the staker whose stake is increased
      */
-    function addToDeposit(address stakerAddress) external payable onlyValidator whenNotPaused {
+    function addToDeposit(address stakerAddress)
+        external
+        payable
+        override
+        onlyValidator
+        whenNotPaused
+    {
         _addToDeposit(stakerAddress, msg.value);
     }