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

package/src/bridge/Bridge.sol

@@ -1,22 +1,13 @@
 // 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 "@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 "./AbsBridge.sol";
+import "./IEthBridge.sol";
 import "./Messages.sol";
 import "../libraries/DelegateCallAware.sol";
 
@@ -24,260 +15,40 @@ import {L1MessageType_batchPostingReport} from "../libraries/MessageTypes.sol";
 
 /**
  * @title Staging ground for incoming and outgoing messages
- * @notice Holds the inbox accumulator for sequenced and delayed messages.
- * It is also the ETH escrow for value sent with these messages.
- * Since the escrow is held here, this contract also contains a list of allowed
- * outboxes that can make calls from here and withdraw this escrow.
+ * @notice It is also the ETH escrow for value sent with these messages.
  */
-contract Bridge is Initializable, DelegateCallAware, IBridge {
+contract Bridge is AbsBridge, IEthBridge {
     using AddressUpgradeable for address;
 
-    struct InOutInfo {
-        uint256 index;
-        bool allowed;
-    }
-
-    mapping(address => InOutInfo) private allowedDelayedInboxesMap;
-    mapping(address => InOutInfo) private allowedOutboxesMap;
-
-    address[] public allowedDelayedInboxList;
-    address[] public allowedOutboxList;
-
-    address internal _activeOutbox;
-
-    /// @inheritdoc IBridge
-    bytes32[] public delayedInboxAccs;
-
-    /// @inheritdoc IBridge
-    bytes32[] public sequencerInboxAccs;
-
-    IOwnable public rollup;
-    address public sequencerInbox;
-
-    uint256 public override sequencerReportedSubMessageCount;
-
-    address internal constant EMPTY_ACTIVEOUTBOX = address(type(uint160).max);
-
+    /// @inheritdoc IEthBridge
     function initialize(IOwnable rollup_) external initializer onlyDelegated {
         _activeOutbox = EMPTY_ACTIVEOUTBOX;
         rollup = rollup_;
     }
 
-    modifier onlyRollupOrOwner() {
-        if (msg.sender != address(rollup)) {
-            address rollupOwner = rollup.owner();
-            if (msg.sender != rollupOwner) {
-                revert NotRollupOrOwner(msg.sender, address(rollup), rollupOwner);
-            }
-        }
-        _;
-    }
-
-    /// @dev returns the address of current active Outbox, or zero if no outbox is active
-    function activeOutbox() public view returns (address) {
-        address outbox = _activeOutbox;
-        // address zero is returned if no outbox is set, but the value used in storage
-        // is non-zero to save users some gas (as storage refunds are usually maxed out)
-        // EIP-1153 would help here.
-        // we don't return `EMPTY_ACTIVEOUTBOX` to avoid a breaking change on the current api
-        if (outbox == EMPTY_ACTIVEOUTBOX) return address(0);
-        return outbox;
-    }
-
-    function allowedDelayedInboxes(address inbox) external view returns (bool) {
-        return allowedDelayedInboxesMap[inbox].allowed;
-    }
-
-    function allowedOutboxes(address outbox) external view returns (bool) {
-        return allowedOutboxesMap[outbox].allowed;
-    }
-
-    modifier onlySequencerInbox() {
-        if (msg.sender != sequencerInbox) revert NotSequencerInbox(msg.sender);
-        _;
-    }
-
-    function enqueueSequencerMessage(
-        bytes32 dataHash,
-        uint256 afterDelayedMessagesRead,
-        uint256 prevMessageCount,
-        uint256 newMessageCount
-    )
-        external
-        onlySequencerInbox
-        returns (
-            uint256 seqMessageIndex,
-            bytes32 beforeAcc,
-            bytes32 delayedAcc,
-            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];
-        }
-        if (afterDelayedMessagesRead > 0) {
-            delayedAcc = delayedInboxAccs[afterDelayedMessagesRead - 1];
-        }
-        acc = keccak256(abi.encodePacked(beforeAcc, dataHash, delayedAcc));
-        sequencerInboxAccs.push(acc);
-    }
-
-    /// @inheritdoc IBridge
-    function submitBatchSpendingReport(address sender, bytes32 messageDataHash)
-        external
-        onlySequencerInbox
-        returns (uint256)
-    {
-        return
-            addMessageToDelayedAccumulator(
-                L1MessageType_batchPostingReport,
-                sender,
-                uint64(block.number),
-                uint64(block.timestamp), // solhint-disable-line not-rely-on-time,
-                block.basefee,
-                messageDataHash
-            );
-    }
-
-    /// @inheritdoc IBridge
+    /// @inheritdoc IEthBridge
     function enqueueDelayedMessage(
         uint8 kind,
         address sender,
         bytes32 messageDataHash
     ) external payable returns (uint256) {
-        if (!allowedDelayedInboxesMap[msg.sender].allowed) revert NotDelayedInbox(msg.sender);
-        return
-            addMessageToDelayedAccumulator(
-                kind,
-                sender,
-                uint64(block.number),
-                uint64(block.timestamp), // solhint-disable-line not-rely-on-time
-                block.basefee,
-                messageDataHash
-            );
+        return _enqueueDelayedMessage(kind, sender, messageDataHash, msg.value);
     }
 
-    function addMessageToDelayedAccumulator(
-        uint8 kind,
-        address sender,
-        uint64 blockNumber,
-        uint64 blockTimestamp,
-        uint256 baseFeeL1,
-        bytes32 messageDataHash
-    ) internal returns (uint256) {
-        uint256 count = delayedInboxAccs.length;
-        bytes32 messageHash = Messages.messageHash(
-            kind,
-            sender,
-            blockNumber,
-            blockTimestamp,
-            count,
-            baseFeeL1,
-            messageDataHash
-        );
-        bytes32 prevAcc = 0;
-        if (count > 0) {
-            prevAcc = delayedInboxAccs[count - 1];
-        }
-        delayedInboxAccs.push(Messages.accumulateInboxMessage(prevAcc, messageHash));
-        emit MessageDelivered(
-            count,
-            prevAcc,
-            msg.sender,
-            kind,
-            sender,
-            messageDataHash,
-            baseFeeL1,
-            blockTimestamp
-        );
-        return count;
+    function _transferFunds(uint256) internal override {
+        // do nothing as Eth transfer is part of TX execution
     }
 
-    function executeCall(
+    function _executeLowLevelCall(
         address to,
         uint256 value,
-        bytes calldata data
-    ) 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;
-        _activeOutbox = msg.sender;
-        // We set and reset active outbox around external call so activeOutbox remains valid during call
-
-        // We use a low level call here since we want to bubble up whether it succeeded or failed to the caller
-        // rather than reverting on failure as well as allow contract and non-contract calls
+        bytes memory data
+    ) internal override returns (bool success, bytes memory returnData) {
         // solhint-disable-next-line avoid-low-level-calls
         (success, returnData) = to.call{value: value}(data);
-        _activeOutbox = prevOutbox;
-        emit BridgeCallTriggered(msg.sender, to, value, data);
-    }
-
-    function setSequencerInbox(address _sequencerInbox) external onlyRollupOrOwner {
-        sequencerInbox = _sequencerInbox;
-        emit SequencerInboxUpdated(_sequencerInbox);
     }
 
-    function setDelayedInbox(address inbox, bool enabled) external onlyRollupOrOwner {
-        InOutInfo storage info = allowedDelayedInboxesMap[inbox];
-        bool alreadyEnabled = info.allowed;
-        emit InboxToggle(inbox, enabled);
-        if (alreadyEnabled == enabled) {
-            return;
-        }
-        if (enabled) {
-            allowedDelayedInboxesMap[inbox] = InOutInfo(allowedDelayedInboxList.length, true);
-            allowedDelayedInboxList.push(inbox);
-        } else {
-            allowedDelayedInboxList[info.index] = allowedDelayedInboxList[
-                allowedDelayedInboxList.length - 1
-            ];
-            allowedDelayedInboxesMap[allowedDelayedInboxList[info.index]].index = info.index;
-            allowedDelayedInboxList.pop();
-            delete allowedDelayedInboxesMap[inbox];
-        }
+    function _baseFeeToReport() internal view override returns (uint256) {
+        return block.basefee;
     }
-
-    function setOutbox(address outbox, bool enabled) external onlyRollupOrOwner {
-        if (outbox == EMPTY_ACTIVEOUTBOX) revert InvalidOutboxSet(outbox);
-
-        InOutInfo storage info = allowedOutboxesMap[outbox];
-        bool alreadyEnabled = info.allowed;
-        emit OutboxToggle(outbox, enabled);
-        if (alreadyEnabled == enabled) {
-            return;
-        }
-        if (enabled) {
-            allowedOutboxesMap[outbox] = InOutInfo(allowedOutboxList.length, true);
-            allowedOutboxList.push(outbox);
-        } else {
-            allowedOutboxList[info.index] = allowedOutboxList[allowedOutboxList.length - 1];
-            allowedOutboxesMap[allowedOutboxList[info.index]].index = info.index;
-            allowedOutboxList.pop();
-            delete allowedOutboxesMap[outbox];
-        }
-    }
-
-    function setSequencerReportedSubMessageCount(uint256 newMsgCount) external onlyRollupOrOwner {
-        sequencerReportedSubMessageCount = newMsgCount;
-    }
-
-    function delayedMessageCount() external view override returns (uint256) {
-        return delayedInboxAccs.length;
-    }
-
-    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/ERC20Bridge.sol

@@ -0,0 +1,74 @@
+// 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.4;
+
+import "./AbsBridge.sol";
+import "./IERC20Bridge.sol";
+import "../libraries/AddressAliasHelper.sol";
+import {InvalidTokenSet, CallTargetNotAllowed} from "../libraries/Error.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+/**
+ * @title Staging ground for incoming and outgoing messages
+ * @notice Unlike the standard Eth bridge, native token bridge escrows the custom ERC20 token which is
+ * used as native currency on L2.
+ */
+contract ERC20Bridge is AbsBridge, IERC20Bridge {
+    using SafeERC20 for IERC20;
+
+    /// @inheritdoc IERC20Bridge
+    address public nativeToken;
+
+    /// @inheritdoc IERC20Bridge
+    function initialize(IOwnable rollup_, address nativeToken_) external initializer onlyDelegated {
+        if (nativeToken_ == address(0)) revert InvalidTokenSet(nativeToken_);
+        nativeToken = nativeToken_;
+        _activeOutbox = EMPTY_ACTIVEOUTBOX;
+        rollup = rollup_;
+    }
+
+    /// @inheritdoc IERC20Bridge
+    function enqueueDelayedMessage(
+        uint8 kind,
+        address sender,
+        bytes32 messageDataHash,
+        uint256 tokenFeeAmount
+    ) external returns (uint256) {
+        return _enqueueDelayedMessage(kind, sender, messageDataHash, tokenFeeAmount);
+    }
+
+    function _transferFunds(uint256 amount) internal override {
+        // fetch native token from Inbox
+        IERC20(nativeToken).safeTransferFrom(msg.sender, address(this), amount);
+    }
+
+    function _executeLowLevelCall(
+        address to,
+        uint256 value,
+        bytes memory data
+    ) internal override returns (bool success, bytes memory returnData) {
+        if (to == nativeToken) {
+            revert CallTargetNotAllowed(nativeToken);
+        }
+
+        // first release native token
+        IERC20(nativeToken).safeTransfer(to, value);
+        success = true;
+
+        // if there's data do additional contract call
+        if (data.length > 0) {
+            // solhint-disable-next-line avoid-low-level-calls
+            (success, returnData) = to.call(data);
+        }
+    }
+
+    function _baseFeeToReport() internal pure override returns (uint256) {
+        // ArbOs uses formula 'l1BaseFee * (1400 + 6 * calldataLengthInBytes)' to calculate retryable ticket's
+        // submission fee. When custom ERC20 token is used to pay for fees, submission fee shall be 0. That's
+        // why baseFee is reported as 0 here.
+        return 0;
+    }
+}

package/src/bridge/ERC20Inbox.sol

@@ -0,0 +1,141 @@
+// 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.4;
+
+import "./AbsInbox.sol";
+import "./IERC20Inbox.sol";
+import "./IERC20Bridge.sol";
+import "../libraries/AddressAliasHelper.sol";
+import {L1MessageType_ethDeposit} from "../libraries/MessageTypes.sol";
+import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.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 ERC20Inbox is AbsInbox, IERC20Inbox {
+    using SafeERC20 for IERC20;
+
+    /// @inheritdoc IInbox
+    function initialize(IBridge _bridge, ISequencerInbox _sequencerInbox)
+        external
+        initializer
+        onlyDelegated
+    {
+        __AbsInbox_init(_bridge, _sequencerInbox);
+
+        // inbox holds native token in transit used to pay for retryable tickets, approve bridge to use it
+        address nativeToken = IERC20Bridge(address(bridge)).nativeToken();
+        IERC20(nativeToken).approve(address(bridge), type(uint256).max);
+    }
+
+    /// @inheritdoc IERC20Inbox
+    function depositERC20(uint256 amount) public whenNotPaused onlyAllowed returns (uint256) {
+        address dest = msg.sender;
+
+        // solhint-disable-next-line avoid-tx-origin
+        if (AddressUpgradeable.isContract(msg.sender) || tx.origin != msg.sender) {
+            // isContract check fails if this function is called during a contract's constructor.
+            dest = AddressAliasHelper.applyL1ToL2Alias(msg.sender);
+        }
+
+        return
+            _deliverMessage(
+                L1MessageType_ethDeposit,
+                msg.sender,
+                abi.encodePacked(dest, amount),
+                amount
+            );
+    }
+
+    /// @inheritdoc IERC20Inbox
+    function createRetryableTicket(
+        address to,
+        uint256 l2CallValue,
+        uint256 maxSubmissionCost,
+        address excessFeeRefundAddress,
+        address callValueRefundAddress,
+        uint256 gasLimit,
+        uint256 maxFeePerGas,
+        uint256 tokenTotalFeeAmount,
+        bytes calldata data
+    ) external whenNotPaused onlyAllowed returns (uint256) {
+        return
+            _createRetryableTicket(
+                to,
+                l2CallValue,
+                maxSubmissionCost,
+                excessFeeRefundAddress,
+                callValueRefundAddress,
+                gasLimit,
+                maxFeePerGas,
+                tokenTotalFeeAmount,
+                data
+            );
+    }
+
+    /// @inheritdoc IERC20Inbox
+    function unsafeCreateRetryableTicket(
+        address to,
+        uint256 l2CallValue,
+        uint256 maxSubmissionCost,
+        address excessFeeRefundAddress,
+        address callValueRefundAddress,
+        uint256 gasLimit,
+        uint256 maxFeePerGas,
+        uint256 tokenTotalFeeAmount,
+        bytes calldata data
+    ) public whenNotPaused onlyAllowed returns (uint256) {
+        return
+            _unsafeCreateRetryableTicket(
+                to,
+                l2CallValue,
+                maxSubmissionCost,
+                excessFeeRefundAddress,
+                callValueRefundAddress,
+                gasLimit,
+                maxFeePerGas,
+                tokenTotalFeeAmount,
+                data
+            );
+    }
+
+    /// @inheritdoc IInbox
+    function calculateRetryableSubmissionFee(uint256, uint256)
+        public
+        pure
+        override(AbsInbox, IInbox)
+        returns (uint256)
+    {
+        // retryable ticket's submission fee is not charged when ERC20 token is used to pay for fees
+        return 0;
+    }
+
+    function _deliverToBridge(
+        uint8 kind,
+        address sender,
+        bytes32 messageDataHash,
+        uint256 tokenAmount
+    ) internal override returns (uint256) {
+        // fetch native token from sender if inbox doesn't already hold enough tokens to pay for fees
+        address nativeToken = IERC20Bridge(address(bridge)).nativeToken();
+        uint256 inboxNativeTokenBalance = IERC20(nativeToken).balanceOf(address(this));
+        if (inboxNativeTokenBalance < tokenAmount) {
+            uint256 diff = tokenAmount - inboxNativeTokenBalance;
+            IERC20(nativeToken).safeTransferFrom(msg.sender, address(this), diff);
+        }
+
+        return
+            IERC20Bridge(address(bridge)).enqueueDelayedMessage(
+                kind,
+                AddressAliasHelper.applyL1ToL2Alias(sender),
+                messageDataHash,
+                tokenAmount
+            );
+    }
+}

package/src/bridge/ERC20Outbox.sol

@@ -0,0 +1,27 @@
+// 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.4;
+
+import "./AbsOutbox.sol";
+
+contract ERC20Outbox is AbsOutbox {
+    uint256 private constant AMOUNT_DEFAULT_CONTEXT = type(uint256).max;
+
+    function l2ToL1WithdrawalAmount() external view returns (uint256) {
+        uint256 amount = context.withdrawalAmount;
+        if (amount == AMOUNT_DEFAULT_CONTEXT) return 0;
+        return amount;
+    }
+
+    /// @inheritdoc AbsOutbox
+    function _defaultContextAmount() internal pure override returns (uint256) {
+        return AMOUNT_DEFAULT_CONTEXT;
+    }
+
+    /// @inheritdoc AbsOutbox
+    function _amountToSetInContext(uint256 value) internal pure override returns (uint256) {
+        return value;
+    }
+}

package/src/bridge/IBridge.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
 
 // solhint-disable-next-line compiler-version
@@ -54,17 +54,6 @@ interface IBridge {
 
     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 executeCall(
         address to,
         uint256 value,
@@ -108,8 +97,4 @@ interface IBridge {
     function setDelayedInbox(address inbox, bool enabled) external;
 
     function setOutbox(address inbox, bool enabled) external;
-
-    // ---------- initializer ----------
-
-    function initialize(IOwnable rollup_) external;
 }

package/src/bridge/IDelayedMessageProvider.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
 
 // solhint-disable-next-line compiler-version

package/src/bridge/IERC20Bridge.sol

@@ -0,0 +1,35 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+// solhint-disable-next-line compiler-version
+pragma solidity >=0.6.9 <0.9.0;
+
+import "./IOwnable.sol";
+import "./IBridge.sol";
+
+interface IERC20Bridge is IBridge {
+    /**
+     * @dev token that is escrowed in bridge on L1 side and minted on L2 as native currency.
+     * Also fees are paid in this token. ERC777, fee on transfer tokens and rebasing tokens
+     * are not supported to be used as chain's native token, as they can break collateralization
+     * invariants.
+     */
+    function nativeToken() external returns (address);
+
+    /**
+     * @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,
+        uint256 tokenFeeAmount
+    ) external returns (uint256);
+
+    // ---------- initializer ----------
+
+    function initialize(IOwnable rollup_, address nativeToken_) external;
+}