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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arbitrum/nitro-contracts",
-  "version": "1.0.0-beta.7",
+  "version": "1.0.0",
   "description": "Layer 2 precompiles and rollup for Arbitrum Nitro",
   "author": "Offchain Labs, Inc.",
   "license": "BUSL-1.1",
@@ -21,7 +21,12 @@
     "build": "./scripts/build.bash",
     "solhint": "solhint -f table src/**/*.sol",
     "prettier:solidity": "prettier --write src/**/*.sol",
-    "hardhat:prod": "hardhat --config hardhat.prod-config.js"
+    "hardhat:prod": "hardhat --config hardhat.prod-config.js",
+    "build:0.6": "INTERFACE_TESTER_SOLC_VERSION=0.6.9 yarn run build",
+    "build:0.7": "INTERFACE_TESTER_SOLC_VERSION=0.7.0 yarn run build",
+    "test:compatibility": "yarn run build:0.6 && yarn run build:0.7",
+    "test:storage": "./test/storage/test.bash",
+    "postinstall": "patch-package"
   },
   "dependencies": {
     "@openzeppelin/contracts": "4.5.0",
@@ -31,6 +36,7 @@
   "private": false,
   "devDependencies": {
     "@nomiclabs/hardhat-ethers": "npm:hardhat-deploy-ethers@^0.3.0-beta.13",
+    "@nomiclabs/hardhat-etherscan": "^3.1.0",
     "@nomiclabs/hardhat-waffle": "^2.0.1",
     "@typechain/ethers-v5": "^10.0.0",
     "@typechain/hardhat": "^6.0.0",
@@ -42,6 +48,8 @@
     "ethers": "^5.5.2",
     "hardhat-deploy": "^0.11.4",
     "hardhat-gas-reporter": "^1.0.8",
+    "patch-package": "^6.4.7",
+    "postinstall-postinstall": "^2.1.0",
     "prettier": "^2.5.1",
     "prettier-plugin-solidity": "^1.0.0-beta.19",
     "solhint": "^3.3.7",
@@ -50,5 +58,8 @@
     "ts-node": "^10.4.0",
     "typechain": "^8.0.0",
     "typescript": "^4.5.4"
+  },
+  "optionalDependencies":{
+    "sol2uml": "2.2.0"
   }
 }

package/src/bridge/Bridge.sol

@@ -7,6 +7,15 @@ pragma solidity ^0.8.4;
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
 
+import {
+    NotContract,
+    NotRollupOrOwner,
+    NotDelayedInbox,
+    NotSequencerInbox,
+    NotOutbox,
+    InvalidOutboxSet,
+    BadSequencerMessageNumber
+} from "../libraries/Error.sol";
 import "./IBridge.sol";
 import "./Messages.sol";
 import "../libraries/DelegateCallAware.sol";
@@ -34,18 +43,20 @@ contract Bridge is Initializable, DelegateCallAware, IBridge {
     address[] public allowedDelayedInboxList;
     address[] public allowedOutboxList;
 
-    address private _activeOutbox;
+    address internal _activeOutbox;
 
-    /// @dev Accumulator for delayed inbox messages; tail represents hash of the current state; each element represents the inclusion of a new message.
-    bytes32[] public override delayedInboxAccs;
+    /// @inheritdoc IBridge
+    bytes32[] public delayedInboxAccs;
 
-    /// @dev Accumulator for sequencer inbox messages; tail represents hash of the current state; each element represents the inclusion of a new message.
-    bytes32[] public override sequencerInboxAccs;
+    /// @inheritdoc IBridge
+    bytes32[] public sequencerInboxAccs;
 
-    IOwnable public override rollup;
+    IOwnable public rollup;
     address public sequencerInbox;
 
-    address private constant EMPTY_ACTIVEOUTBOX = address(type(uint160).max);
+    uint256 public override sequencerReportedSubMessageCount;
+
+    address internal constant EMPTY_ACTIVEOUTBOX = address(type(uint160).max);
 
     function initialize(IOwnable rollup_) external initializer onlyDelegated {
         _activeOutbox = EMPTY_ACTIVEOUTBOX;
@@ -73,11 +84,11 @@ contract Bridge is Initializable, DelegateCallAware, IBridge {
         return outbox;
     }
 
-    function allowedDelayedInboxes(address inbox) external view override returns (bool) {
+    function allowedDelayedInboxes(address inbox) external view returns (bool) {
         return allowedDelayedInboxesMap[inbox].allowed;
     }
 
-    function allowedOutboxes(address outbox) external view override returns (bool) {
+    function allowedOutboxes(address outbox) external view returns (bool) {
         return allowedOutboxesMap[outbox].allowed;
     }
 
@@ -86,9 +97,13 @@ contract Bridge is Initializable, DelegateCallAware, IBridge {
         _;
     }
 
-    function enqueueSequencerMessage(bytes32 dataHash, uint256 afterDelayedMessagesRead)
+    function enqueueSequencerMessage(
+        bytes32 dataHash,
+        uint256 afterDelayedMessagesRead,
+        uint256 prevMessageCount,
+        uint256 newMessageCount
+    )
         external
-        override
         onlySequencerInbox
         returns (
             uint256 seqMessageIndex,
@@ -97,6 +112,14 @@ contract Bridge is Initializable, DelegateCallAware, IBridge {
             bytes32 acc
         )
     {
+        if (
+            sequencerReportedSubMessageCount != prevMessageCount &&
+            prevMessageCount != 0 &&
+            sequencerReportedSubMessageCount != 0
+        ) {
+            revert BadSequencerMessageNumber(sequencerReportedSubMessageCount, prevMessageCount);
+        }
+        sequencerReportedSubMessageCount = newMessageCount;
         seqMessageIndex = sequencerInboxAccs.length;
         if (sequencerInboxAccs.length > 0) {
             beforeAcc = sequencerInboxAccs[sequencerInboxAccs.length - 1];
@@ -108,15 +131,9 @@ contract Bridge is Initializable, DelegateCallAware, IBridge {
         sequencerInboxAccs.push(acc);
     }
 
-    /**
-     * @dev allows the sequencer inbox to submit a delayed message of the batchPostingReport type
-     * This is done through a separate function entrypoint instead of allowing the sequencer inbox
-     * to call `enqueueDelayedMessage` to avoid the gas overhead of an extra SLOAD in either
-     * every delayed inbox or every sequencer inbox call.
-     */
+    /// @inheritdoc IBridge
     function submitBatchSpendingReport(address sender, bytes32 messageDataHash)
         external
-        override
         onlySequencerInbox
         returns (uint256)
     {
@@ -131,16 +148,12 @@ contract Bridge is Initializable, DelegateCallAware, IBridge {
             );
     }
 
-    /**
-     * @dev Enqueue a message in the delayed inbox accumulator.
-     * These messages are later sequenced in the SequencerInbox, either by the sequencer as
-     * part of a normal batch, or by force inclusion.
-     */
+    /// @inheritdoc IBridge
     function enqueueDelayedMessage(
         uint8 kind,
         address sender,
         bytes32 messageDataHash
-    ) external payable override returns (uint256) {
+    ) external payable returns (uint256) {
         if (!allowedDelayedInboxesMap[msg.sender].allowed) revert NotDelayedInbox(msg.sender);
         return
             addMessageToDelayedAccumulator(
@@ -193,7 +206,7 @@ contract Bridge is Initializable, DelegateCallAware, IBridge {
         address to,
         uint256 value,
         bytes calldata data
-    ) external override returns (bool success, bytes memory returnData) {
+    ) external returns (bool success, bytes memory returnData) {
         if (!allowedOutboxesMap[msg.sender].allowed) revert NotOutbox(msg.sender);
         if (data.length > 0 && !to.isContract()) revert NotContract(to);
         address prevOutbox = _activeOutbox;
@@ -208,12 +221,12 @@ contract Bridge is Initializable, DelegateCallAware, IBridge {
         emit BridgeCallTriggered(msg.sender, to, value, data);
     }
 
-    function setSequencerInbox(address _sequencerInbox) external override onlyRollupOrOwner {
+    function setSequencerInbox(address _sequencerInbox) external onlyRollupOrOwner {
         sequencerInbox = _sequencerInbox;
         emit SequencerInboxUpdated(_sequencerInbox);
     }
 
-    function setDelayedInbox(address inbox, bool enabled) external override onlyRollupOrOwner {
+    function setDelayedInbox(address inbox, bool enabled) external onlyRollupOrOwner {
         InOutInfo storage info = allowedDelayedInboxesMap[inbox];
         bool alreadyEnabled = info.allowed;
         emit InboxToggle(inbox, enabled);
@@ -233,7 +246,7 @@ contract Bridge is Initializable, DelegateCallAware, IBridge {
         }
     }
 
-    function setOutbox(address outbox, bool enabled) external override onlyRollupOrOwner {
+    function setOutbox(address outbox, bool enabled) external onlyRollupOrOwner {
         if (outbox == EMPTY_ACTIVEOUTBOX) revert InvalidOutboxSet(outbox);
 
         InOutInfo storage info = allowedOutboxesMap[outbox];
@@ -253,11 +266,18 @@ contract Bridge is Initializable, DelegateCallAware, IBridge {
         }
     }
 
+    function setSequencerReportedSubMessageCount(uint256 newMsgCount) external onlyRollupOrOwner {
+        sequencerReportedSubMessageCount = newMsgCount;
+    }
+
     function delayedMessageCount() external view override returns (uint256) {
         return delayedInboxAccs.length;
     }
 
-    function sequencerMessageCount() external view override returns (uint256) {
+    function sequencerMessageCount() external view returns (uint256) {
         return sequencerInboxAccs.length;
     }
+
+    /// @dev For the classic -> nitro migration. TODO: remove post-migration.
+    function acceptFundsFromOldBridge() external payable {}
 }

package/src/bridge/IBridge.sol

@@ -2,27 +2,11 @@
 // For license information, see https://github.com/nitro/blob/master/LICENSE
 // SPDX-License-Identifier: BUSL-1.1
 
-pragma solidity ^0.8.4;
+// solhint-disable-next-line compiler-version
+pragma solidity >=0.6.9 <0.9.0;
 
-import {NotContract, NotRollupOrOwner} from "../libraries/Error.sol";
 import "./IOwnable.sol";
 
-/// @dev Thrown when an un-authorized address tries to access an only-inbox function
-/// @param sender The un-authorized sender
-error NotDelayedInbox(address sender);
-
-/// @dev Thrown when an un-authorized address tries to access an only-sequencer-inbox function
-/// @param sender The un-authorized sender
-error NotSequencerInbox(address sender);
-
-/// @dev Thrown when an un-authorized address tries to access an only-outbox function
-/// @param sender The un-authorized sender
-error NotOutbox(address sender);
-
-/// @dev the provided outbox address isn't valid
-/// @param outbox address of outbox being set
-error InvalidOutboxSet(address outbox);
-
 interface IBridge {
     event MessageDelivered(
         uint256 indexed messageIndex,
@@ -48,13 +32,57 @@ interface IBridge {
 
     event SequencerInboxUpdated(address newSequencerInbox);
 
+    function allowedDelayedInboxList(uint256) external returns (address);
+
+    function allowedOutboxList(uint256) external returns (address);
+
+    /// @dev Accumulator for delayed inbox messages; tail represents hash of the current state; each element represents the inclusion of a new message.
+    function delayedInboxAccs(uint256) external view returns (bytes32);
+
+    /// @dev Accumulator for sequencer inbox messages; tail represents hash of the current state; each element represents the inclusion of a new message.
+    function sequencerInboxAccs(uint256) external view returns (bytes32);
+
+    function rollup() external view returns (IOwnable);
+
+    function sequencerInbox() external view returns (address);
+
+    function activeOutbox() external view returns (address);
+
+    function allowedDelayedInboxes(address inbox) external view returns (bool);
+
+    function allowedOutboxes(address outbox) external view returns (bool);
+
+    function sequencerReportedSubMessageCount() external view returns (uint256);
+
+    /**
+     * @dev Enqueue a message in the delayed inbox accumulator.
+     *      These messages are later sequenced in the SequencerInbox, either
+     *      by the sequencer as part of a normal batch, or by force inclusion.
+     */
     function enqueueDelayedMessage(
         uint8 kind,
         address sender,
         bytes32 messageDataHash
     ) external payable returns (uint256);
 
-    function enqueueSequencerMessage(bytes32 dataHash, uint256 afterDelayedMessagesRead)
+    function executeCall(
+        address to,
+        uint256 value,
+        bytes calldata data
+    ) external returns (bool success, bytes memory returnData);
+
+    function delayedMessageCount() external view returns (uint256);
+
+    function sequencerMessageCount() external view returns (uint256);
+
+    // ---------- onlySequencerInbox functions ----------
+
+    function enqueueSequencerMessage(
+        bytes32 dataHash,
+        uint256 afterDelayedMessagesRead,
+        uint256 prevMessageCount,
+        uint256 newMessageCount
+    )
         external
         returns (
             uint256 seqMessageIndex,
@@ -63,40 +91,25 @@ interface IBridge {
             bytes32 acc
         );
 
+    /**
+     * @dev Allows the sequencer inbox to submit a delayed message of the batchPostingReport type
+     *      This is done through a separate function entrypoint instead of allowing the sequencer inbox
+     *      to call `enqueueDelayedMessage` to avoid the gas overhead of an extra SLOAD in either
+     *      every delayed inbox or every sequencer inbox call.
+     */
     function submitBatchSpendingReport(address batchPoster, bytes32 dataHash)
         external
         returns (uint256 msgNum);
 
-    function executeCall(
-        address to,
-        uint256 value,
-        bytes calldata data
-    ) external returns (bool success, bytes memory returnData);
-
-    // These are only callable by the admin
-    function setDelayedInbox(address inbox, bool enabled) external;
-
-    function setOutbox(address inbox, bool enabled) external;
+    // ---------- onlyRollupOrOwner functions ----------
 
     function setSequencerInbox(address _sequencerInbox) external;
 
-    // View functions
-
-    function sequencerInbox() external view returns (address);
-
-    function activeOutbox() external view returns (address);
-
-    function allowedDelayedInboxes(address inbox) external view returns (bool);
-
-    function allowedOutboxes(address outbox) external view returns (bool);
-
-    function delayedInboxAccs(uint256 index) external view returns (bytes32);
-
-    function sequencerInboxAccs(uint256 index) external view returns (bytes32);
+    function setDelayedInbox(address inbox, bool enabled) external;
 
-    function delayedMessageCount() external view returns (uint256);
+    function setOutbox(address inbox, bool enabled) external;
 
-    function sequencerMessageCount() external view returns (uint256);
+    // ---------- initializer ----------
 
-    function rollup() external view returns (IOwnable);
+    function initialize(IOwnable rollup_) external;
 }

package/src/bridge/IDelayedMessageProvider.sol

@@ -2,7 +2,8 @@
 // For license information, see https://github.com/nitro/blob/master/LICENSE
 // SPDX-License-Identifier: BUSL-1.1
 
-pragma solidity ^0.8.0;
+// solhint-disable-next-line compiler-version
+pragma solidity >=0.6.9 <0.9.0;
 
 interface IDelayedMessageProvider {
     /// @dev event emitted when a inbox message is added to the Bridge's delayed accumulator

package/src/bridge/IInbox.sol

@@ -2,47 +2,48 @@
 // For license information, see https://github.com/nitro/blob/master/LICENSE
 // SPDX-License-Identifier: BUSL-1.1
 
-pragma solidity ^0.8.4;
+// solhint-disable-next-line compiler-version
+pragma solidity >=0.6.9 <0.9.0;
 
 import "./IBridge.sol";
 import "./IDelayedMessageProvider.sol";
-import {AlreadyInit, NotOrigin, DataTooLarge} from "../libraries/Error.sol";
+import "./ISequencerInbox.sol";
 
-/// @dev The contract is paused, so cannot be paused
-error AlreadyPaused();
-
-/// @dev The contract is unpaused, so cannot be unpaused
-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 IDelayedMessageProvider {
+    function bridge() external view returns (IBridge);
 
-/// @dev address not allowed to interact with the given contract
-error NotAllowedOrigin(address origin);
+    function sequencerInbox() external view returns (ISequencerInbox);
+
+    /**
+     * @notice Send a generic L2 message to the chain
+     * @dev This method is an optimization to avoid having to emit the entirety of the messageData in a log. Instead validators are expected to be able to parse the data from the transaction's input
+     *      This method will be disabled upon L1 fork to prevent replay attacks on L2
+     * @param messageData Data of the message being sent
+     */
+    function sendL2MessageFromOrigin(bytes calldata messageData) external returns (uint256);
+
+    /**
+     * @notice Send a generic L2 message to the chain
+     * @dev This method can be used to send any type of message that doesn't require L1 validation
+     *      This method will be disabled upon L1 fork to prevent replay attacks on L2
+     * @param messageData Data of the message being sent
+     */
+    function sendL2Message(bytes calldata messageData) external returns (uint256);
 
-/// @dev used to convey retryable tx data in eth calls without requiring a tx trace
-/// this follows a pattern similar to EIP-3668 where reverts surface call information
-error RetryableData(
-    address from,
-    address to,
-    uint256 l2CallValue,
-    uint256 deposit,
-    uint256 maxSubmissionCost,
-    address excessFeeRefundAddress,
-    address callValueRefundAddress,
-    uint256 gasLimit,
-    uint256 maxFeePerGas,
-    bytes data
-);
+    function sendL1FundedUnsignedTransaction(
+        uint256 gasLimit,
+        uint256 maxFeePerGas,
+        uint256 nonce,
+        address to,
+        bytes calldata data
+    ) external payable returns (uint256);
 
-interface IInbox is IDelayedMessageProvider {
-    function sendL2Message(bytes calldata messageData) external returns (uint256);
+    function sendL1FundedContractTransaction(
+        uint256 gasLimit,
+        uint256 maxFeePerGas,
+        address to,
+        bytes calldata data
+    ) external payable returns (uint256);
 
     function sendUnsignedTransaction(
         uint256 gasLimit,
@@ -61,7 +62,11 @@ interface IInbox is IDelayedMessageProvider {
         bytes calldata data
     ) external returns (uint256);
 
-    function sendL1FundedUnsignedTransaction(
+    /**
+     * @dev This method can only be called upon L1 fork and will not alias the caller
+     *      This method will revert if not called from origin
+     */
+    function sendL1FundedUnsignedTransactionToFork(
         uint256 gasLimit,
         uint256 maxFeePerGas,
         uint256 nonce,
@@ -69,42 +74,120 @@ interface IInbox is IDelayedMessageProvider {
         bytes calldata data
     ) external payable returns (uint256);
 
-    function sendL1FundedContractTransaction(
+    /**
+     * @dev This method can only be called upon L1 fork and will not alias the caller
+     *      This method will revert if not called from origin
+     */
+    function sendUnsignedTransactionToFork(
         uint256 gasLimit,
         uint256 maxFeePerGas,
+        uint256 nonce,
         address to,
+        uint256 value,
         bytes calldata data
-    ) external payable returns (uint256);
+    ) external returns (uint256);
+
+    /**
+     * @notice Send a message to initiate L2 withdrawal
+     * @dev This method can only be called upon L1 fork and will not alias the caller
+     *      This method will revert if not called from origin
+     */
+    function sendWithdrawEthToFork(
+        uint256 gasLimit,
+        uint256 maxFeePerGas,
+        uint256 nonce,
+        uint256 value,
+        address withdrawTo
+    ) external returns (uint256);
+
+    /**
+     * @notice Get the L1 fee for submitting a retryable
+     * @dev This fee can be paid by funds already in the L2 aliased address or by the current message value
+     * @dev This formula may change in the future, to future proof your code query this method instead of inlining!!
+     * @param dataLength The length of the retryable's calldata, in bytes
+     * @param baseFee The block basefee when the retryable is included in the chain, if 0 current block.basefee will be used
+     */
+    function calculateRetryableSubmissionFee(uint256 dataLength, uint256 baseFee)
+        external
+        view
+        returns (uint256);
+
+    /**
+     * @notice Deposit eth from L1 to L2 to address of the sender if sender is an EOA, and to its aliased address if the sender is a contract
+     * @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() external payable returns (uint256);
 
-    /// @dev Gas limit and maxFeePerGas should not be set to 1 as that is used to trigger the RetryableData error
+    /**
+     * @notice Put a message in the L2 inbox that can be reexecuted for some fixed amount of time if it reverts
+     * @dev all msg.value will deposited to callValueRefundAddress on L2
+     * @dev Gas limit and maxFeePerGas should not be set to 1 as that is used to trigger the RetryableData error
+     * @param to destination L2 contract address
+     * @param l2CallValue call value for retryable L2 message
+     * @param maxSubmissionCost Max gas deducted from user's L2 balance to cover base submission fee
+     * @param excessFeeRefundAddress gasLimit x maxFeePerGas - execution cost gets credited here on L2 balance
+     * @param callValueRefundAddress l2Callvalue gets credited here on L2 if retryable txn times out or gets cancelled
+     * @param gasLimit Max gas deducted from user's L2 balance to cover L2 execution. Should not be set to 1 (magic value used to trigger the RetryableData error)
+     * @param maxFeePerGas price bid for L2 execution. Should not be set to 1 (magic value used to trigger the RetryableData error)
+     * @param data ABI encoded data of L2 message
+     * @return unique message number of the retryable transaction
+     */
     function createRetryableTicket(
         address to,
-        uint256 arbTxCallValue,
+        uint256 l2CallValue,
         uint256 maxSubmissionCost,
-        address submissionRefundAddress,
-        address valueRefundAddress,
+        address excessFeeRefundAddress,
+        address callValueRefundAddress,
         uint256 gasLimit,
         uint256 maxFeePerGas,
         bytes calldata data
     ) external payable returns (uint256);
 
-    /// @notice TEMPORARILY DISABLED as exact mechanics are being worked out
-    /// @dev Gas limit and maxFeePerGas should not be set to 1 as that is used to trigger the RetryableData error
+    /**
+     * @notice Put a message in the L2 inbox that can be reexecuted for some fixed amount of time if it reverts
+     * @dev Same as createRetryableTicket, but does not guarantee that submission will succeed by requiring the needed funds
+     * come from the deposit alone, rather than falling back on the user's L2 balance
+     * @dev Advanced usage only (does not rewrite aliases for excessFeeRefundAddress and callValueRefundAddress).
+     * createRetryableTicket method is the recommended standard.
+     * @dev Gas limit and maxFeePerGas should not be set to 1 as that is used to trigger the RetryableData error
+     * @param to destination L2 contract address
+     * @param l2CallValue call value for retryable L2 message
+     * @param maxSubmissionCost Max gas deducted from user's L2 balance to cover base submission fee
+     * @param excessFeeRefundAddress gasLimit x maxFeePerGas - execution cost gets credited here on L2 balance
+     * @param callValueRefundAddress l2Callvalue gets credited here on L2 if retryable txn times out or gets cancelled
+     * @param gasLimit Max gas deducted from user's L2 balance to cover L2 execution. Should not be set to 1 (magic value used to trigger the RetryableData error)
+     * @param maxFeePerGas price bid for L2 execution. Should not be set to 1 (magic value used to trigger the RetryableData error)
+     * @param data ABI encoded data of L2 message
+     * @return unique message number of the retryable transaction
+     */
     function unsafeCreateRetryableTicket(
         address to,
-        uint256 arbTxCallValue,
+        uint256 l2CallValue,
         uint256 maxSubmissionCost,
-        address submissionRefundAddress,
-        address valueRefundAddress,
+        address excessFeeRefundAddress,
+        address callValueRefundAddress,
         uint256 gasLimit,
         uint256 maxFeePerGas,
         bytes calldata data
     ) external payable returns (uint256);
 
-    function depositEth() external payable returns (uint256);
+    // ---------- onlyRollupOrOwner functions ----------
 
-    /// @notice deprecated in favour of depositEth with no parameters
-    function depositEth(uint256 maxSubmissionCost) external payable returns (uint256);
+    /// @notice pauses all inbox functionality
+    function pause() external;
 
-    function bridge() external view returns (IBridge);
+    /// @notice unpauses all inbox functionality
+    function unpause() external;
+
+    // ---------- initializer ----------
+
+    /**
+     * @dev function to be called one time during the inbox upgrade process
+     *      this is used to fix the storage slots
+     */
+    function postUpgradeInit(IBridge _bridge) external;
+
+    function initialize(IBridge _bridge, ISequencerInbox _sequencerInbox) external;
 }