@arbitrum/nitro-contracts 2.1.0 → 3.0.0-alpha.0

package/src/bridge/Inbox.sol

@@ -4,16 +4,7 @@
 
 pragma solidity ^0.8.4;
 
-import {
-    NotOrigin,
-    DataTooLarge,
-    InsufficientValue,
-    InsufficientSubmissionCost,
-    RetryableData,
-    L1Forked,
-    NotForked,
-    GasLimitTooLarge
-} from "../libraries/Error.sol";
+import {NotOrigin, NotForked, GasLimitTooLarge} from "../libraries/Error.sol";
 import "./AbsInbox.sol";
 import "./IInbox.sol";
 import "./IBridge.sol";
@@ -22,7 +13,6 @@ import "../libraries/AddressAliasHelper.sol";
 import {
     L2_MSG,
     L1MessageType_L2FundedByL1,
-    L1MessageType_submitRetryableTx,
     L1MessageType_ethDeposit,
     L2MessageType_unsignedEOATx,
     L2MessageType_unsignedContractTx
@@ -37,19 +27,22 @@ import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
  * to await inclusion in the SequencerInbox
  */
 contract Inbox is AbsInbox, IInbox {
-    constructor(uint256 _maxDataSize) AbsInbox(_maxDataSize) {}
+    constructor(
+        uint256 _maxDataSize
+    ) AbsInbox(_maxDataSize) {}
 
     /// @inheritdoc IInboxBase
-    function initialize(IBridge _bridge, ISequencerInbox _sequencerInbox)
-        external
-        initializer
-        onlyDelegated
-    {
+    function initialize(
+        IBridge _bridge,
+        ISequencerInbox _sequencerInbox
+    ) external initializer onlyDelegated {
         __AbsInbox_init(_bridge, _sequencerInbox);
     }
 
     /// @inheritdoc IInbox
-    function postUpgradeInit(IBridge) external onlyDelegated onlyProxyOwner {}
+    function postUpgradeInit(
+        IBridge
+    ) external onlyDelegated onlyProxyOwner {}
 
     /// @inheritdoc IInbox
     function sendL1FundedUnsignedTransaction(
@@ -63,21 +56,20 @@ contract Inbox is AbsInbox, IInbox {
         if (gasLimit > type(uint64).max) {
             revert GasLimitTooLarge();
         }
-        return
-            _deliverMessage(
-                L1MessageType_L2FundedByL1,
-                msg.sender,
-                abi.encodePacked(
-                    L2MessageType_unsignedEOATx,
-                    gasLimit,
-                    maxFeePerGas,
-                    nonce,
-                    uint256(uint160(to)),
-                    msg.value,
-                    data
-                ),
-                msg.value
-            );
+        return _deliverMessage(
+            L1MessageType_L2FundedByL1,
+            msg.sender,
+            abi.encodePacked(
+                L2MessageType_unsignedEOATx,
+                gasLimit,
+                maxFeePerGas,
+                nonce,
+                uint256(uint160(to)),
+                msg.value,
+                data
+            ),
+            msg.value
+        );
     }
 
     /// @inheritdoc IInbox
@@ -91,20 +83,19 @@ contract Inbox is AbsInbox, IInbox {
         if (gasLimit > type(uint64).max) {
             revert GasLimitTooLarge();
         }
-        return
-            _deliverMessage(
-                L1MessageType_L2FundedByL1,
-                msg.sender,
-                abi.encodePacked(
-                    L2MessageType_unsignedContractTx,
-                    gasLimit,
-                    maxFeePerGas,
-                    uint256(uint160(to)),
-                    msg.value,
-                    data
-                ),
-                msg.value
-            );
+        return _deliverMessage(
+            L1MessageType_L2FundedByL1,
+            msg.sender,
+            abi.encodePacked(
+                L2MessageType_unsignedContractTx,
+                gasLimit,
+                maxFeePerGas,
+                uint256(uint160(to)),
+                msg.value,
+                data
+            ),
+            msg.value
+        );
     }
 
     /// @inheritdoc IInbox
@@ -122,22 +113,21 @@ contract Inbox is AbsInbox, IInbox {
         if (gasLimit > type(uint64).max) {
             revert GasLimitTooLarge();
         }
-        return
-            _deliverMessage(
-                L1MessageType_L2FundedByL1,
-                // undoing sender alias here to cancel out the aliasing
-                AddressAliasHelper.undoL1ToL2Alias(msg.sender),
-                abi.encodePacked(
-                    L2MessageType_unsignedEOATx,
-                    gasLimit,
-                    maxFeePerGas,
-                    nonce,
-                    uint256(uint160(to)),
-                    msg.value,
-                    data
-                ),
-                msg.value
-            );
+        return _deliverMessage(
+            L1MessageType_L2FundedByL1,
+            // undoing sender alias here to cancel out the aliasing
+            AddressAliasHelper.undoL1ToL2Alias(msg.sender),
+            abi.encodePacked(
+                L2MessageType_unsignedEOATx,
+                gasLimit,
+                maxFeePerGas,
+                nonce,
+                uint256(uint160(to)),
+                msg.value,
+                data
+            ),
+            msg.value
+        );
     }
 
     /// @inheritdoc IInbox
@@ -156,22 +146,21 @@ contract Inbox is AbsInbox, IInbox {
         if (gasLimit > type(uint64).max) {
             revert GasLimitTooLarge();
         }
-        return
-            _deliverMessage(
-                L2_MSG,
-                // undoing sender alias here to cancel out the aliasing
-                AddressAliasHelper.undoL1ToL2Alias(msg.sender),
-                abi.encodePacked(
-                    L2MessageType_unsignedEOATx,
-                    gasLimit,
-                    maxFeePerGas,
-                    nonce,
-                    uint256(uint160(to)),
-                    value,
-                    data
-                ),
-                0
-            );
+        return _deliverMessage(
+            L2_MSG,
+            // undoing sender alias here to cancel out the aliasing
+            AddressAliasHelper.undoL1ToL2Alias(msg.sender),
+            abi.encodePacked(
+                L2MessageType_unsignedEOATx,
+                gasLimit,
+                maxFeePerGas,
+                nonce,
+                uint256(uint160(to)),
+                value,
+                data
+            ),
+            0
+        );
     }
 
     /// @inheritdoc IInbox
@@ -189,22 +178,21 @@ contract Inbox is AbsInbox, IInbox {
         if (gasLimit > type(uint64).max) {
             revert GasLimitTooLarge();
         }
-        return
-            _deliverMessage(
-                L2_MSG,
-                // undoing sender alias here to cancel out the aliasing
-                AddressAliasHelper.undoL1ToL2Alias(msg.sender),
-                abi.encodePacked(
-                    L2MessageType_unsignedEOATx,
-                    gasLimit,
-                    maxFeePerGas,
-                    nonce,
-                    uint256(uint160(address(100))), // ArbSys address
-                    value,
-                    abi.encodeWithSelector(ArbSys.withdrawEth.selector, withdrawTo)
-                ),
-                0
-            );
+        return _deliverMessage(
+            L2_MSG,
+            // undoing sender alias here to cancel out the aliasing
+            AddressAliasHelper.undoL1ToL2Alias(msg.sender),
+            abi.encodePacked(
+                L2MessageType_unsignedEOATx,
+                gasLimit,
+                maxFeePerGas,
+                nonce,
+                uint256(uint160(address(100))), // ArbSys address
+                value,
+                abi.encodeWithSelector(ArbSys.withdrawEth.selector, withdrawTo)
+            ),
+            0
+        );
     }
 
     /// @inheritdoc IInbox
@@ -217,17 +205,15 @@ contract Inbox is AbsInbox, IInbox {
             dest = AddressAliasHelper.applyL1ToL2Alias(msg.sender);
         }
 
-        return
-            _deliverMessage(
-                L1MessageType_ethDeposit,
-                msg.sender,
-                abi.encodePacked(dest, msg.value),
-                msg.value
-            );
+        return _deliverMessage(
+            L1MessageType_ethDeposit, msg.sender, abi.encodePacked(dest, msg.value), msg.value
+        );
     }
 
     /// @notice deprecated in favour of depositEth with no parameters
-    function depositEth(uint256) external payable whenNotPaused onlyAllowed returns (uint256) {
+    function depositEth(
+        uint256
+    ) external payable whenNotPaused onlyAllowed returns (uint256) {
         return depositEth();
     }
 
@@ -256,17 +242,16 @@ contract Inbox is AbsInbox, IInbox {
         bytes calldata data
     ) external payable whenNotPaused onlyAllowed returns (uint256) {
         // gas limit is validated to be within uint64 in unsafeCreateRetryableTicket
-        return
-            unsafeCreateRetryableTicket(
-                to,
-                l2CallValue,
-                maxSubmissionCost,
-                excessFeeRefundAddress,
-                callValueRefundAddress,
-                gasLimit,
-                maxFeePerGas,
-                data
-            );
+        return unsafeCreateRetryableTicket(
+            to,
+            l2CallValue,
+            maxSubmissionCost,
+            excessFeeRefundAddress,
+            callValueRefundAddress,
+            gasLimit,
+            maxFeePerGas,
+            data
+        );
     }
 
     /// @inheritdoc IInbox
@@ -280,18 +265,17 @@ contract Inbox is AbsInbox, IInbox {
         uint256 maxFeePerGas,
         bytes calldata data
     ) external payable whenNotPaused onlyAllowed returns (uint256) {
-        return
-            _createRetryableTicket(
-                to,
-                l2CallValue,
-                maxSubmissionCost,
-                excessFeeRefundAddress,
-                callValueRefundAddress,
-                gasLimit,
-                maxFeePerGas,
-                msg.value,
-                data
-            );
+        return _createRetryableTicket(
+            to,
+            l2CallValue,
+            maxSubmissionCost,
+            excessFeeRefundAddress,
+            callValueRefundAddress,
+            gasLimit,
+            maxFeePerGas,
+            msg.value,
+            data
+        );
     }
 
     /// @inheritdoc IInbox
@@ -305,27 +289,24 @@ contract Inbox is AbsInbox, IInbox {
         uint256 maxFeePerGas,
         bytes calldata data
     ) public payable whenNotPaused onlyAllowed returns (uint256) {
-        return
-            _unsafeCreateRetryableTicket(
-                to,
-                l2CallValue,
-                maxSubmissionCost,
-                excessFeeRefundAddress,
-                callValueRefundAddress,
-                gasLimit,
-                maxFeePerGas,
-                msg.value,
-                data
-            );
+        return _unsafeCreateRetryableTicket(
+            to,
+            l2CallValue,
+            maxSubmissionCost,
+            excessFeeRefundAddress,
+            callValueRefundAddress,
+            gasLimit,
+            maxFeePerGas,
+            msg.value,
+            data
+        );
     }
 
     /// @inheritdoc IInboxBase
-    function calculateRetryableSubmissionFee(uint256 dataLength, uint256 baseFee)
-        public
-        view
-        override(AbsInbox, IInboxBase)
-        returns (uint256)
-    {
+    function calculateRetryableSubmissionFee(
+        uint256 dataLength,
+        uint256 baseFee
+    ) public view override(AbsInbox, IInboxBase) returns (uint256) {
         // Use current block basefee if baseFee parameter is 0
         return (1400 + 6 * dataLength) * (baseFee == 0 ? block.basefee : baseFee);
     }
@@ -336,16 +317,15 @@ contract Inbox is AbsInbox, IInbox {
         bytes32 messageDataHash,
         uint256 amount
     ) internal override returns (uint256) {
-        return
-            IEthBridge(address(bridge)).enqueueDelayedMessage{value: amount}(
-                kind,
-                AddressAliasHelper.applyL1ToL2Alias(sender),
-                messageDataHash
-            );
+        return IEthBridge(address(bridge)).enqueueDelayedMessage{value: amount}(
+            kind, AddressAliasHelper.applyL1ToL2Alias(sender), messageDataHash
+        );
     }
 
     /// @inheritdoc AbsInbox
-    function _fromNativeTo18Decimals(uint256 value) internal pure override returns (uint256) {
+    function _fromNativeTo18Decimals(
+        uint256 value
+    ) internal pure override returns (uint256) {
         return value;
     }
 }

package/src/bridge/Messages.sol

@@ -2,9 +2,35 @@
 // For license information, see https://github.com/OffchainLabs/nitro-contracts/blob/main/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;
+pragma experimental ABIEncoderV2;
 
 library Messages {
+    struct Message {
+        uint8 kind;
+        address sender;
+        uint64 blockNumber;
+        uint64 timestamp;
+        uint256 inboxSeqNum;
+        uint256 baseFeeL1;
+        bytes32 messageDataHash;
+    }
+
+    function messageHash(
+        Message memory message
+    ) internal pure returns (bytes32) {
+        return messageHash(
+            message.kind,
+            message.sender,
+            message.blockNumber,
+            message.timestamp,
+            message.inboxSeqNum,
+            message.baseFeeL1,
+            message.messageDataHash
+        );
+    }
+
     function messageHash(
         uint8 kind,
         address sender,
@@ -14,25 +40,29 @@ library Messages {
         uint256 baseFeeL1,
         bytes32 messageDataHash
     ) internal pure returns (bytes32) {
-        return
-            keccak256(
-                abi.encodePacked(
-                    kind,
-                    sender,
-                    blockNumber,
-                    timestamp,
-                    inboxSeqNum,
-                    baseFeeL1,
-                    messageDataHash
-                )
-            );
+        return keccak256(
+            abi.encodePacked(
+                kind, sender, blockNumber, timestamp, inboxSeqNum, baseFeeL1, messageDataHash
+            )
+        );
     }
 
-    function accumulateInboxMessage(bytes32 prevAcc, bytes32 message)
-        internal
-        pure
-        returns (bytes32)
-    {
+    function accumulateInboxMessage(
+        bytes32 prevAcc,
+        bytes32 message
+    ) internal pure returns (bytes32) {
         return keccak256(abi.encodePacked(prevAcc, message));
     }
+
+    /// @dev   Validates a delayed accumulator preimage
+    /// @param delayedAcc The delayed accumulator to validate against
+    /// @param beforeDelayedAcc The previous delayed accumulator
+    /// @param message The message to validate
+    function isValidDelayedAccPreimage(
+        bytes32 delayedAcc,
+        bytes32 beforeDelayedAcc,
+        Message memory message
+    ) internal pure returns (bool) {
+        return delayedAcc == accumulateInboxMessage(beforeDelayedAcc, messageHash(message));
+    }
 }

package/src/bridge/Outbox.sol

@@ -15,12 +15,16 @@ contract Outbox is AbsOutbox {
     }
 
     /// @inheritdoc AbsOutbox
-    function _getAmountToUnlock(uint256 value) internal pure override returns (uint256) {
+    function _getAmountToUnlock(
+        uint256 value
+    ) internal pure override returns (uint256) {
         return value;
     }
 
     /// @inheritdoc AbsOutbox
-    function _amountToSetInContext(uint256) internal pure override returns (uint256) {
+    function _amountToSetInContext(
+        uint256
+    ) internal pure override returns (uint256) {
         // In ETH-based chains withdrawal amount can be read from msg.value. For that reason
         // amount slot in context will never be accessed, we keep it as 0 all the time
         return 0;