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

package/src/bridge/AbsInbox.sol

@@ -0,0 +1,335 @@
+// 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 {
+    DataTooLarge,
+    GasLimitTooLarge,
+    InsufficientValue,
+    InsufficientSubmissionCost,
+    L1Forked,
+    NotAllowedOrigin,
+    NotOrigin,
+    NotRollupOrOwner,
+    RetryableData
+} from "../libraries/Error.sol";
+import "./IInbox.sol";
+import "./ISequencerInbox.sol";
+import "./IBridge.sol";
+import "../libraries/AddressAliasHelper.sol";
+import "../libraries/DelegateCallAware.sol";
+import {
+    L1MessageType_submitRetryableTx,
+    L2MessageType_unsignedContractTx,
+    L2MessageType_unsignedEOATx,
+    L2_MSG
+} from "../libraries/MessageTypes.sol";
+import {MAX_DATA_SIZE} from "../libraries/Constants.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
+ */
+abstract contract AbsInbox is DelegateCallAware, PausableUpgradeable, IInbox {
+    /// @inheritdoc IInbox
+    IBridge public bridge;
+    /// @inheritdoc IInbox
+    ISequencerInbox public sequencerInbox;
+
+    /// ------------------------------------ allow list start ------------------------------------ ///
+
+    /// @inheritdoc IInbox
+    bool public allowListEnabled;
+
+    /// @inheritdoc IInbox
+    mapping(address => bool) public isAllowed;
+
+    event AllowListAddressSet(address indexed user, bool val);
+    event AllowListEnabledUpdated(bool isEnabled);
+
+    /// @inheritdoc IInbox
+    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]);
+        }
+    }
+
+    /// @inheritdoc IInbox
+    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();
+    }
+
+    /// @inheritdoc IInbox
+    function unpause() external onlyRollupOrOwner {
+        _unpause();
+    }
+
+    /* solhint-disable func-name-mixedcase */
+    function __AbsInbox_init(IBridge _bridge, ISequencerInbox _sequencerInbox)
+        internal
+        onlyInitializing
+    {
+        bridge = _bridge;
+        sequencerInbox = _sequencerInbox;
+        allowListEnabled = false;
+        __Pausable_init();
+    }
+
+    /// @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), 0);
+        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, 0);
+    }
+
+    /// @inheritdoc IInbox
+    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
+                ),
+                0
+            );
+    }
+
+    /// @inheritdoc IInbox
+    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
+                ),
+                0
+            );
+    }
+
+    function _createRetryableTicket(
+        address to,
+        uint256 l2CallValue,
+        uint256 maxSubmissionCost,
+        address excessFeeRefundAddress,
+        address callValueRefundAddress,
+        uint256 gasLimit,
+        uint256 maxFeePerGas,
+        uint256 amount,
+        bytes calldata data
+    ) internal returns (uint256) {
+        // ensure the user's deposit alone will make submission succeed
+        if (amount < (maxSubmissionCost + l2CallValue + gasLimit * maxFeePerGas)) {
+            revert InsufficientValue(
+                maxSubmissionCost + l2CallValue + gasLimit * maxFeePerGas,
+                amount
+            );
+        }
+
+        // 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(
+                to,
+                l2CallValue,
+                maxSubmissionCost,
+                excessFeeRefundAddress,
+                callValueRefundAddress,
+                gasLimit,
+                maxFeePerGas,
+                amount,
+                data
+            );
+    }
+
+    function _unsafeCreateRetryableTicket(
+        address to,
+        uint256 l2CallValue,
+        uint256 maxSubmissionCost,
+        address excessFeeRefundAddress,
+        address callValueRefundAddress,
+        uint256 gasLimit,
+        uint256 maxFeePerGas,
+        uint256 amount,
+        bytes calldata data
+    ) internal 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,
+                amount,
+                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,
+                    amount,
+                    maxSubmissionCost,
+                    uint256(uint160(excessFeeRefundAddress)),
+                    uint256(uint160(callValueRefundAddress)),
+                    gasLimit,
+                    maxFeePerGas,
+                    data.length,
+                    data
+                ),
+                amount
+            );
+    }
+
+    function _deliverMessage(
+        uint8 _kind,
+        address _sender,
+        bytes memory _messageData,
+        uint256 amount
+    ) internal returns (uint256) {
+        if (_messageData.length > MAX_DATA_SIZE)
+            revert DataTooLarge(_messageData.length, MAX_DATA_SIZE);
+        uint256 msgNum = _deliverToBridge(_kind, _sender, keccak256(_messageData), amount);
+        emit InboxMessageDelivered(msgNum, _messageData);
+        return msgNum;
+    }
+
+    function _deliverToBridge(
+        uint8 kind,
+        address sender,
+        bytes32 messageDataHash,
+        uint256 amount
+    ) internal virtual returns (uint256);
+
+    function calculateRetryableSubmissionFee(uint256 dataLength, uint256 baseFee)
+        public
+        view
+        virtual
+        returns (uint256);
+}

package/src/bridge/AbsOutbox.sol

@@ -0,0 +1,295 @@
+// 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 {
+    AlreadyInit,
+    NotRollup,
+    ProofTooLong,
+    PathNotMinimal,
+    UnknownRoot,
+    AlreadySpent,
+    BridgeCallFailed,
+    HadZeroInit
+} from "../libraries/Error.sol";
+import "./IBridge.sol";
+import "./IOutbox.sol";
+import "../libraries/MerkleLib.sol";
+import "../libraries/DelegateCallAware.sol";
+
+/// @dev this error is thrown since certain functions are only expected to be used in simulations, not in actual txs
+error SimulationOnlyEntrypoint();
+
+abstract contract AbsOutbox is DelegateCallAware, IOutbox {
+    address public rollup; // the rollup contract
+    IBridge public bridge; // the bridge contract
+
+    mapping(uint256 => bytes32) public spent; // packed spent bitmap
+    mapping(bytes32 => bytes32) public roots; // maps root hashes => L2 block hash
+
+    // we're packing this struct into 4 storage slots
+    // 1st slot: timestamp, l2Block (128 bits each, max ~3.4*10^38)
+    // 2nd slot: outputId (256 bits)
+    // 3rd slot: l1Block (96 bits, max ~7.9*10^28), sender (address 160 bits)
+    // 4th slot: withdrawalAmount (256 bits)
+    struct L2ToL1Context {
+        uint128 l2Block;
+        uint128 timestamp;
+        bytes32 outputId;
+        address sender;
+        uint96 l1Block;
+        uint256 withdrawalAmount;
+    }
+
+    // Note, these variables are set and then wiped during a single transaction.
+    // Therefore their values don't need to be maintained, and their slots will
+    // hold default values (which are interpreted as empty values) outside of transactions
+    L2ToL1Context internal context;
+
+    // default context values to be used in storage instead of zero, to save on storage refunds
+    // it is assumed that arb-os never assigns these values to a valid leaf to be redeemed
+    uint128 private constant L2BLOCK_DEFAULT_CONTEXT = type(uint128).max;
+    uint96 private constant L1BLOCK_DEFAULT_CONTEXT = type(uint96).max;
+    uint128 private constant TIMESTAMP_DEFAULT_CONTEXT = type(uint128).max;
+    bytes32 private constant OUTPUTID_DEFAULT_CONTEXT = bytes32(type(uint256).max);
+    address private constant SENDER_DEFAULT_CONTEXT = address(type(uint160).max);
+
+    uint128 public constant OUTBOX_VERSION = 2;
+
+    function initialize(IBridge _bridge) external onlyDelegated {
+        if (address(_bridge) == address(0)) revert HadZeroInit();
+        if (address(bridge) != address(0)) revert AlreadyInit();
+        // address zero is returned if no context is set, but the values used in storage
+        // are non-zero to save users some gas (as storage refunds are usually maxed out)
+        // EIP-1153 would help here
+        context = L2ToL1Context({
+            l2Block: L2BLOCK_DEFAULT_CONTEXT,
+            l1Block: L1BLOCK_DEFAULT_CONTEXT,
+            timestamp: TIMESTAMP_DEFAULT_CONTEXT,
+            outputId: OUTPUTID_DEFAULT_CONTEXT,
+            sender: SENDER_DEFAULT_CONTEXT,
+            withdrawalAmount: _defaultContextAmount()
+        });
+        bridge = _bridge;
+        rollup = address(_bridge.rollup());
+    }
+
+    function updateSendRoot(bytes32 root, bytes32 l2BlockHash) external {
+        if (msg.sender != rollup) revert NotRollup(msg.sender, rollup);
+        roots[root] = l2BlockHash;
+        emit SendRootUpdated(root, l2BlockHash);
+    }
+
+    /// @inheritdoc IOutbox
+    function l2ToL1Sender() external view returns (address) {
+        address sender = context.sender;
+        // we don't return the default context value to avoid a breaking change in the API
+        if (sender == SENDER_DEFAULT_CONTEXT) return address(0);
+        return sender;
+    }
+
+    /// @inheritdoc IOutbox
+    function l2ToL1Block() external view returns (uint256) {
+        uint128 l2Block = context.l2Block;
+        // we don't return the default context value to avoid a breaking change in the API
+        if (l2Block == L2BLOCK_DEFAULT_CONTEXT) return uint256(0);
+        return uint256(l2Block);
+    }
+
+    /// @inheritdoc IOutbox
+    function l2ToL1EthBlock() external view returns (uint256) {
+        uint96 l1Block = context.l1Block;
+        // we don't return the default context value to avoid a breaking change in the API
+        if (l1Block == L1BLOCK_DEFAULT_CONTEXT) return uint256(0);
+        return uint256(l1Block);
+    }
+
+    /// @inheritdoc IOutbox
+    function l2ToL1Timestamp() external view returns (uint256) {
+        uint128 timestamp = context.timestamp;
+        // we don't return the default context value to avoid a breaking change in the API
+        if (timestamp == TIMESTAMP_DEFAULT_CONTEXT) return uint256(0);
+        return uint256(timestamp);
+    }
+
+    /// @notice batch number is deprecated and now always returns 0
+    function l2ToL1BatchNum() external pure returns (uint256) {
+        return 0;
+    }
+
+    /// @inheritdoc IOutbox
+    function l2ToL1OutputId() external view returns (bytes32) {
+        bytes32 outputId = context.outputId;
+        // we don't return the default context value to avoid a breaking change in the API
+        if (outputId == OUTPUTID_DEFAULT_CONTEXT) return bytes32(0);
+        return outputId;
+    }
+
+    /// @inheritdoc IOutbox
+    function executeTransaction(
+        bytes32[] calldata proof,
+        uint256 index,
+        address l2Sender,
+        address to,
+        uint256 l2Block,
+        uint256 l1Block,
+        uint256 l2Timestamp,
+        uint256 value,
+        bytes calldata data
+    ) external {
+        bytes32 userTx = calculateItemHash(
+            l2Sender,
+            to,
+            l2Block,
+            l1Block,
+            l2Timestamp,
+            value,
+            data
+        );
+
+        recordOutputAsSpent(proof, index, userTx);
+
+        executeTransactionImpl(index, l2Sender, to, l2Block, l1Block, l2Timestamp, value, data);
+    }
+
+    /// @inheritdoc IOutbox
+    function executeTransactionSimulation(
+        uint256 index,
+        address l2Sender,
+        address to,
+        uint256 l2Block,
+        uint256 l1Block,
+        uint256 l2Timestamp,
+        uint256 value,
+        bytes calldata data
+    ) external {
+        if (msg.sender != address(0)) revert SimulationOnlyEntrypoint();
+        executeTransactionImpl(index, l2Sender, to, l2Block, l1Block, l2Timestamp, value, data);
+    }
+
+    function executeTransactionImpl(
+        uint256 outputId,
+        address l2Sender,
+        address to,
+        uint256 l2Block,
+        uint256 l1Block,
+        uint256 l2Timestamp,
+        uint256 value,
+        bytes calldata data
+    ) internal {
+        emit OutBoxTransactionExecuted(to, l2Sender, 0, outputId);
+
+        // we temporarily store the previous values so the outbox can naturally
+        // unwind itself when there are nested calls to `executeTransaction`
+        L2ToL1Context memory prevContext = context;
+
+        context = L2ToL1Context({
+            sender: l2Sender,
+            l2Block: uint128(l2Block),
+            l1Block: uint96(l1Block),
+            timestamp: uint128(l2Timestamp),
+            outputId: bytes32(outputId),
+            withdrawalAmount: _amountToSetInContext(value)
+        });
+
+        // set and reset vars around execution so they remain valid during call
+        executeBridgeCall(to, value, data);
+
+        context = prevContext;
+    }
+
+    function _calcSpentIndexOffset(uint256 index)
+        internal
+        view
+        returns (
+            uint256,
+            uint256,
+            bytes32
+        )
+    {
+        uint256 spentIndex = index / 255; // Note: Reserves the MSB.
+        uint256 bitOffset = index % 255;
+        bytes32 replay = spent[spentIndex];
+        return (spentIndex, bitOffset, replay);
+    }
+
+    function _isSpent(uint256 bitOffset, bytes32 replay) internal pure returns (bool) {
+        return ((replay >> bitOffset) & bytes32(uint256(1))) != bytes32(0);
+    }
+
+    /// @inheritdoc IOutbox
+    function isSpent(uint256 index) external view returns (bool) {
+        (, uint256 bitOffset, bytes32 replay) = _calcSpentIndexOffset(index);
+        return _isSpent(bitOffset, replay);
+    }
+
+    function recordOutputAsSpent(
+        bytes32[] memory proof,
+        uint256 index,
+        bytes32 item
+    ) internal {
+        if (proof.length >= 256) revert ProofTooLong(proof.length);
+        if (index >= 2**proof.length) revert PathNotMinimal(index, 2**proof.length);
+
+        // Hash the leaf an extra time to prove it's a leaf
+        bytes32 calcRoot = calculateMerkleRoot(proof, index, item);
+        if (roots[calcRoot] == bytes32(0)) revert UnknownRoot(calcRoot);
+
+        (uint256 spentIndex, uint256 bitOffset, bytes32 replay) = _calcSpentIndexOffset(index);
+
+        if (_isSpent(bitOffset, replay)) revert AlreadySpent(index);
+        spent[spentIndex] = (replay | bytes32(1 << bitOffset));
+    }
+
+    function executeBridgeCall(
+        address to,
+        uint256 value,
+        bytes memory data
+    ) internal {
+        (bool success, bytes memory returndata) = bridge.executeCall(to, value, data);
+        if (!success) {
+            if (returndata.length > 0) {
+                // solhint-disable-next-line no-inline-assembly
+                assembly {
+                    let returndata_size := mload(returndata)
+                    revert(add(32, returndata), returndata_size)
+                }
+            } else {
+                revert BridgeCallFailed();
+            }
+        }
+    }
+
+    function calculateItemHash(
+        address l2Sender,
+        address to,
+        uint256 l2Block,
+        uint256 l1Block,
+        uint256 l2Timestamp,
+        uint256 value,
+        bytes calldata data
+    ) public pure returns (bytes32) {
+        return
+            keccak256(abi.encodePacked(l2Sender, to, l2Block, l1Block, l2Timestamp, value, data));
+    }
+
+    function calculateMerkleRoot(
+        bytes32[] memory proof,
+        uint256 path,
+        bytes32 item
+    ) public pure returns (bytes32) {
+        return MerkleLib.calculateRoot(proof, path, keccak256(abi.encodePacked(item)));
+    }
+
+    /// @notice default value to be used for 'amount' field in L2ToL1Context outside of transaction execution.
+    /// @return default 'amount' in case of ERC20-based rollup is type(uint256).max, or 0 in case of ETH-based rollup
+    function _defaultContextAmount() internal pure virtual returns (uint256);
+
+    /// @notice value to be set for 'amount' field in L2ToL1Context during L2 to L1 transaction execution.
+    ///         In case of ERC20-based rollup this is the amount of native token being withdrawn. In case of standard ETH-based
+    ///         rollup this amount shall always be 0, because amount of ETH being withdrawn can be read from msg.value.
+    /// @return amount of native token being withdrawn in case of ERC20-based rollup, or 0 in case of ETH-based rollup
+    function _amountToSetInContext(uint256 value) internal pure virtual returns (uint256);
+}