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

package/src/bridge/Inbox.sol

@@ -1,32 +1,24 @@
 // 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.4;
 
 import {
-    AlreadyInit,
     NotOrigin,
     DataTooLarge,
-    AlreadyPaused,
-    AlreadyUnpaused,
-    Paused,
     InsufficientValue,
     InsufficientSubmissionCost,
-    NotAllowedOrigin,
     RetryableData,
-    NotRollupOrOwner,
     L1Forked,
     NotForked,
     GasLimitTooLarge
 } from "../libraries/Error.sol";
-import "./IInbox.sol";
-import "./ISequencerInbox.sol";
+import "./AbsInbox.sol";
+import "./IEthInbox.sol";
 import "./IBridge.sol";
-
-import "./Messages.sol";
+import "./IEthBridge.sol";
 import "../libraries/AddressAliasHelper.sol";
-import "../libraries/DelegateCallAware.sol";
 import {
     L2_MSG,
     L1MessageType_L2FundedByL1,
@@ -35,125 +27,30 @@ import {
     L2MessageType_unsignedEOATx,
     L2MessageType_unsignedContractTx
 } from "../libraries/MessageTypes.sol";
-import {MAX_DATA_SIZE, UNISWAP_L1_TIMELOCK, UNISWAP_L2_FACTORY} from "../libraries/Constants.sol";
+import {MAX_DATA_SIZE} from "../libraries/Constants.sol";
 import "../precompiles/ArbSys.sol";
 
 import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
-import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
 
 /**
  * @title Inbox for user and contract originated messages
  * @notice Messages created via this inbox are enqueued in the delayed accumulator
  * to await inclusion in the SequencerInbox
  */
-contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
-    IBridge public bridge;
-    ISequencerInbox public sequencerInbox;
-
-    /// ------------------------------------ allow list start ------------------------------------ ///
-
-    bool public allowListEnabled;
-    mapping(address => bool) public isAllowed;
-
-    event AllowListAddressSet(address indexed user, bool val);
-    event AllowListEnabledUpdated(bool isEnabled);
-
-    function setAllowList(address[] memory user, bool[] memory val) external onlyRollupOrOwner {
-        require(user.length == val.length, "INVALID_INPUT");
-
-        for (uint256 i = 0; i < user.length; i++) {
-            isAllowed[user[i]] = val[i];
-            emit AllowListAddressSet(user[i], val[i]);
-        }
-    }
-
-    function setAllowListEnabled(bool _allowListEnabled) external onlyRollupOrOwner {
-        require(_allowListEnabled != allowListEnabled, "ALREADY_SET");
-        allowListEnabled = _allowListEnabled;
-        emit AllowListEnabledUpdated(_allowListEnabled);
-    }
-
-    /// @dev this modifier checks the tx.origin instead of msg.sender for convenience (ie it allows
-    /// allowed users to interact with the token bridge without needing the token bridge to be allowList aware).
-    /// this modifier is not intended to use to be used for security (since this opens the allowList to
-    /// a smart contract phishing risk).
-    modifier onlyAllowed() {
-        // solhint-disable-next-line avoid-tx-origin
-        if (allowListEnabled && !isAllowed[tx.origin]) revert NotAllowedOrigin(tx.origin);
-        _;
-    }
-
-    /// ------------------------------------ allow list end ------------------------------------ ///
-
-    modifier onlyRollupOrOwner() {
-        IOwnable rollup = bridge.rollup();
-        if (msg.sender != address(rollup)) {
-            address rollupOwner = rollup.owner();
-            if (msg.sender != rollupOwner) {
-                revert NotRollupOrOwner(msg.sender, address(rollup), rollupOwner);
-            }
-        }
-        _;
-    }
-
-    uint256 internal immutable deployTimeChainId = block.chainid;
-
-    function _chainIdChanged() internal view returns (bool) {
-        return deployTimeChainId != block.chainid;
-    }
-
-    /// @inheritdoc IInbox
-    function pause() external onlyRollupOrOwner {
-        _pause();
-    }
-
+contract Inbox is AbsInbox, IEthInbox {
     /// @inheritdoc IInbox
-    function unpause() external onlyRollupOrOwner {
-        _unpause();
-    }
-
     function initialize(IBridge _bridge, ISequencerInbox _sequencerInbox)
         external
         initializer
         onlyDelegated
     {
-        bridge = _bridge;
-        sequencerInbox = _sequencerInbox;
-        allowListEnabled = false;
-        __Pausable_init();
+        __AbsInbox_init(_bridge, _sequencerInbox);
     }
 
-    /// @inheritdoc IInbox
+    /// @inheritdoc IEthInbox
     function postUpgradeInit(IBridge) external onlyDelegated onlyProxyOwner {}
 
-    /// @inheritdoc IInbox
-    function sendL2MessageFromOrigin(bytes calldata messageData)
-        external
-        whenNotPaused
-        onlyAllowed
-        returns (uint256)
-    {
-        if (_chainIdChanged()) revert L1Forked();
-        // solhint-disable-next-line avoid-tx-origin
-        if (msg.sender != tx.origin) revert NotOrigin();
-        if (messageData.length > MAX_DATA_SIZE)
-            revert DataTooLarge(messageData.length, MAX_DATA_SIZE);
-        uint256 msgNum = deliverToBridge(L2_MSG, msg.sender, keccak256(messageData));
-        emit InboxMessageDeliveredFromOrigin(msgNum);
-        return msgNum;
-    }
-
-    /// @inheritdoc IInbox
-    function sendL2Message(bytes calldata messageData)
-        external
-        whenNotPaused
-        onlyAllowed
-        returns (uint256)
-    {
-        if (_chainIdChanged()) revert L1Forked();
-        return _deliverMessage(L2_MSG, msg.sender, messageData);
-    }
-
+    /// @inheritdoc IEthInbox
     function sendL1FundedUnsignedTransaction(
         uint256 gasLimit,
         uint256 maxFeePerGas,
@@ -177,10 +74,12 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
                     uint256(uint160(to)),
                     msg.value,
                     data
-                )
+                ),
+                msg.value
             );
     }
 
+    /// @inheritdoc IEthInbox
     function sendL1FundedContractTransaction(
         uint256 gasLimit,
         uint256 maxFeePerGas,
@@ -202,65 +101,12 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
                     uint256(uint160(to)),
                     msg.value,
                     data
-                )
-            );
-    }
-
-    function sendUnsignedTransaction(
-        uint256 gasLimit,
-        uint256 maxFeePerGas,
-        uint256 nonce,
-        address to,
-        uint256 value,
-        bytes calldata data
-    ) external whenNotPaused onlyAllowed returns (uint256) {
-        // arbos will discard unsigned tx with gas limit too large
-        if (gasLimit > type(uint64).max) {
-            revert GasLimitTooLarge();
-        }
-        return
-            _deliverMessage(
-                L2_MSG,
-                msg.sender,
-                abi.encodePacked(
-                    L2MessageType_unsignedEOATx,
-                    gasLimit,
-                    maxFeePerGas,
-                    nonce,
-                    uint256(uint160(to)),
-                    value,
-                    data
-                )
-            );
-    }
-
-    function sendContractTransaction(
-        uint256 gasLimit,
-        uint256 maxFeePerGas,
-        address to,
-        uint256 value,
-        bytes calldata data
-    ) external whenNotPaused onlyAllowed returns (uint256) {
-        // arbos will discard unsigned tx with gas limit too large
-        if (gasLimit > type(uint64).max) {
-            revert GasLimitTooLarge();
-        }
-        return
-            _deliverMessage(
-                L2_MSG,
-                msg.sender,
-                abi.encodePacked(
-                    L2MessageType_unsignedContractTx,
-                    gasLimit,
-                    maxFeePerGas,
-                    uint256(uint160(to)),
-                    value,
-                    data
-                )
+                ),
+                msg.value
             );
     }
 
-    /// @inheritdoc IInbox
+    /// @inheritdoc IEthInbox
     function sendL1FundedUnsignedTransactionToFork(
         uint256 gasLimit,
         uint256 maxFeePerGas,
@@ -288,11 +134,12 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
                     uint256(uint160(to)),
                     msg.value,
                     data
-                )
+                ),
+                msg.value
             );
     }
 
-    /// @inheritdoc IInbox
+    /// @inheritdoc IEthInbox
     function sendUnsignedTransactionToFork(
         uint256 gasLimit,
         uint256 maxFeePerGas,
@@ -321,11 +168,12 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
                     uint256(uint160(to)),
                     value,
                     data
-                )
+                ),
+                0
             );
     }
 
-    /// @inheritdoc IInbox
+    /// @inheritdoc IEthInbox
     function sendWithdrawEthToFork(
         uint256 gasLimit,
         uint256 maxFeePerGas,
@@ -353,21 +201,12 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
                     uint256(uint160(address(100))), // ArbSys address
                     value,
                     abi.encodeWithSelector(ArbSys.withdrawEth.selector, withdrawTo)
-                )
+                ),
+                0
             );
     }
 
-    /// @inheritdoc IInbox
-    function calculateRetryableSubmissionFee(uint256 dataLength, uint256 baseFee)
-        public
-        view
-        returns (uint256)
-    {
-        // Use current block basefee if baseFee parameter is 0
-        return (1400 + 6 * dataLength) * (baseFee == 0 ? block.basefee : baseFee);
-    }
-
-    /// @inheritdoc IInbox
+    /// @inheritdoc IEthInbox
     function depositEth() public payable whenNotPaused onlyAllowed returns (uint256) {
         address dest = msg.sender;
 
@@ -381,7 +220,8 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
             _deliverMessage(
                 L1MessageType_ethDeposit,
                 msg.sender,
-                abi.encodePacked(dest, msg.value)
+                abi.encodePacked(dest, msg.value),
+                msg.value
             );
     }
 
@@ -428,7 +268,7 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
             );
     }
 
-    /// @inheritdoc IInbox
+    /// @inheritdoc IEthInbox
     function createRetryableTicket(
         address to,
         uint256 l2CallValue,
@@ -439,28 +279,8 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
         uint256 maxFeePerGas,
         bytes calldata data
     ) external payable whenNotPaused onlyAllowed returns (uint256) {
-        // ensure the user's deposit alone will make submission succeed
-        if (msg.value < (maxSubmissionCost + l2CallValue + gasLimit * maxFeePerGas)) {
-            revert InsufficientValue(
-                maxSubmissionCost + l2CallValue + gasLimit * maxFeePerGas,
-                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
-        // since the beneficiary and other refund addresses don't get rewritten by arb-os
-        if (AddressUpgradeable.isContract(excessFeeRefundAddress)) {
-            excessFeeRefundAddress = AddressAliasHelper.applyL1ToL2Alias(excessFeeRefundAddress);
-        }
-        if (AddressUpgradeable.isContract(callValueRefundAddress)) {
-            // this is the beneficiary. be careful since this is the address that can cancel the retryable in the L2
-            callValueRefundAddress = AddressAliasHelper.applyL1ToL2Alias(callValueRefundAddress);
-        }
-
-        // gas limit is validated to be within uint64 in unsafeCreateRetryableTicket
         return
-            unsafeCreateRetryableTicket(
+            _createRetryableTicket(
                 to,
                 l2CallValue,
                 maxSubmissionCost,
@@ -468,11 +288,12 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
                 callValueRefundAddress,
                 gasLimit,
                 maxFeePerGas,
+                msg.value,
                 data
             );
     }
 
-    /// @inheritdoc IInbox
+    /// @inheritdoc IEthInbox
     function unsafeCreateRetryableTicket(
         address to,
         uint256 l2CallValue,
@@ -483,147 +304,39 @@ contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
         uint256 maxFeePerGas,
         bytes calldata data
     ) public payable whenNotPaused onlyAllowed returns (uint256) {
-        // gas price and limit of 1 should never be a valid input, so instead they are used as
-        // magic values to trigger a revert in eth calls that surface data without requiring a tx trace
-        if (gasLimit == 1 || maxFeePerGas == 1)
-            revert RetryableData(
-                msg.sender,
-                to,
-                l2CallValue,
-                msg.value,
-                maxSubmissionCost,
-                excessFeeRefundAddress,
-                callValueRefundAddress,
-                gasLimit,
-                maxFeePerGas,
-                data
-            );
-
-        // arbos will discard retryable with gas limit too large
-        if (gasLimit > type(uint64).max) {
-            revert GasLimitTooLarge();
-        }
-
-        uint256 submissionFee = calculateRetryableSubmissionFee(data.length, block.basefee);
-        if (maxSubmissionCost < submissionFee)
-            revert InsufficientSubmissionCost(submissionFee, maxSubmissionCost);
-
         return
-            _deliverMessage(
-                L1MessageType_submitRetryableTx,
-                msg.sender,
-                abi.encodePacked(
-                    uint256(uint160(to)),
-                    l2CallValue,
-                    msg.value,
-                    maxSubmissionCost,
-                    uint256(uint160(excessFeeRefundAddress)),
-                    uint256(uint160(callValueRefundAddress)),
-                    gasLimit,
-                    maxFeePerGas,
-                    data.length,
-                    data
-                )
-            );
-    }
-
-    /// @notice This is an one-time-exception to resolve a misconfiguration of Uniswap Arbitrum deployment
-    ///         Only the Uniswap L1 Timelock may call this function and it is allowed to create a crosschain
-    ///         retryable ticket without address aliasing. More info here:
-    ///         https://gov.uniswap.org/t/consensus-check-fix-the-cross-chain-messaging-bridge-on-arbitrum/18547
-    /// @dev    This function will be removed in future releases
-    function uniswapCreateRetryableTicket(
-        address to,
-        uint256 l2CallValue,
-        uint256 maxSubmissionCost,
-        address excessFeeRefundAddress,
-        address callValueRefundAddress,
-        uint256 gasLimit,
-        uint256 maxFeePerGas,
-        bytes calldata data
-    ) external payable whenNotPaused onlyAllowed returns (uint256) {
-        // this can only be called by UNISWAP_L1_TIMELOCK
-        require(msg.sender == UNISWAP_L1_TIMELOCK, "NOT_UNISWAP_L1_TIMELOCK");
-        // the retryable can only call UNISWAP_L2_FACTORY
-        require(to == UNISWAP_L2_FACTORY, "NOT_TO_UNISWAP_L2_FACTORY");
-
-        // ensure the user's deposit alone will make submission succeed
-        if (msg.value < (maxSubmissionCost + l2CallValue + gasLimit * maxFeePerGas)) {
-            revert InsufficientValue(
-                maxSubmissionCost + l2CallValue + gasLimit * maxFeePerGas,
-                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
-        // since the beneficiary and other refund addresses don't get rewritten by arb-os
-        if (AddressUpgradeable.isContract(excessFeeRefundAddress)) {
-            excessFeeRefundAddress = AddressAliasHelper.applyL1ToL2Alias(excessFeeRefundAddress);
-        }
-        if (AddressUpgradeable.isContract(callValueRefundAddress)) {
-            // this is the beneficiary. be careful since this is the address that can cancel the retryable in the L2
-            callValueRefundAddress = AddressAliasHelper.applyL1ToL2Alias(callValueRefundAddress);
-        }
-
-        // gas price and limit of 1 should never be a valid input, so instead they are used as
-        // magic values to trigger a revert in eth calls that surface data without requiring a tx trace
-        if (gasLimit == 1 || maxFeePerGas == 1)
-            revert RetryableData(
-                msg.sender,
+            _unsafeCreateRetryableTicket(
                 to,
                 l2CallValue,
-                msg.value,
                 maxSubmissionCost,
                 excessFeeRefundAddress,
                 callValueRefundAddress,
                 gasLimit,
                 maxFeePerGas,
+                msg.value,
                 data
             );
-
-        uint256 submissionFee = calculateRetryableSubmissionFee(data.length, block.basefee);
-        if (maxSubmissionCost < submissionFee)
-            revert InsufficientSubmissionCost(submissionFee, maxSubmissionCost);
-
-        return
-            _deliverMessage(
-                L1MessageType_submitRetryableTx,
-                AddressAliasHelper.undoL1ToL2Alias(msg.sender),
-                abi.encodePacked(
-                    uint256(uint160(to)),
-                    l2CallValue,
-                    msg.value,
-                    maxSubmissionCost,
-                    uint256(uint160(excessFeeRefundAddress)),
-                    uint256(uint160(callValueRefundAddress)),
-                    gasLimit,
-                    maxFeePerGas,
-                    data.length,
-                    data
-                )
-            );
     }
 
-    function _deliverMessage(
-        uint8 _kind,
-        address _sender,
-        bytes memory _messageData
-    ) internal returns (uint256) {
-        if (_messageData.length > MAX_DATA_SIZE)
-            revert DataTooLarge(_messageData.length, MAX_DATA_SIZE);
-        uint256 msgNum = deliverToBridge(_kind, _sender, keccak256(_messageData));
-        emit InboxMessageDelivered(msgNum, _messageData);
-        return msgNum;
+    /// @inheritdoc IInbox
+    function calculateRetryableSubmissionFee(uint256 dataLength, uint256 baseFee)
+        public
+        view
+        override(AbsInbox, IInbox)
+        returns (uint256)
+    {
+        // Use current block basefee if baseFee parameter is 0
+        return (1400 + 6 * dataLength) * (baseFee == 0 ? block.basefee : baseFee);
     }
 
-    function deliverToBridge(
+    function _deliverToBridge(
         uint8 kind,
         address sender,
-        bytes32 messageDataHash
-    ) internal returns (uint256) {
+        bytes32 messageDataHash,
+        uint256 amount
+    ) internal override returns (uint256) {
         return
-            bridge.enqueueDelayedMessage{value: msg.value}(
+            IEthBridge(address(bridge)).enqueueDelayedMessage{value: amount}(
                 kind,
                 AddressAliasHelper.applyL1ToL2Alias(sender),
                 messageDataHash

package/src/bridge/Messages.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;