@hyperlane-xyz/core 1.5.6-beta0 → 1.5.8

package/contracts/Mailbox.sol

@@ -3,53 +3,51 @@ pragma solidity >=0.8.0;
 
 // ============ Internal Imports ============
 import {Versioned} from "./upgrade/Versioned.sol";
-import {Indexed} from "./libs/Indexed.sol";
+import {MerkleLib} from "./libs/Merkle.sol";
 import {Message} from "./libs/Message.sol";
 import {TypeCasts} from "./libs/TypeCasts.sol";
-import {IInterchainSecurityModule, ISpecifiesInterchainSecurityModule} from "./interfaces/IInterchainSecurityModule.sol";
-import {IPostDispatchHook} from "./interfaces/hooks/IPostDispatchHook.sol";
 import {IMessageRecipient} from "./interfaces/IMessageRecipient.sol";
+import {IInterchainSecurityModule, ISpecifiesInterchainSecurityModule} from "./interfaces/IInterchainSecurityModule.sol";
 import {IMailbox} from "./interfaces/IMailbox.sol";
+import {PausableReentrancyGuardUpgradeable} from "./PausableReentrancyGuard.sol";
 
 // ============ External Imports ============
 import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 
-contract Mailbox is IMailbox, Indexed, Versioned, OwnableUpgradeable {
+contract Mailbox is
+    IMailbox,
+    OwnableUpgradeable,
+    PausableReentrancyGuardUpgradeable,
+    Versioned
+{
     // ============ Libraries ============
 
+    using MerkleLib for MerkleLib.Tree;
     using Message for bytes;
     using TypeCasts for bytes32;
     using TypeCasts for address;
 
     // ============ Constants ============
 
+    // Maximum bytes per message = 2 KiB (somewhat arbitrarily set to begin)
+    uint256 public constant MAX_MESSAGE_BODY_BYTES = 2 * 2**10;
     // Domain of chain on which the contract is deployed
     uint32 public immutable localDomain;
 
     // ============ Public Storage ============
 
-    // A monotonically increasing nonce for outbound unique message IDs.
-    uint32 public nonce;
-
-    // The latest dispatched message ID used for auth in post-dispatch hooks.
-    bytes32 public latestDispatchedId;
-
     // The default ISM, used if the recipient fails to specify one.
     IInterchainSecurityModule public defaultIsm;
+    // An incremental merkle tree used to store outbound message IDs.
+    MerkleLib.Tree public tree;
+    // Mapping of message ID to whether or not that message has been delivered.
+    mapping(bytes32 => bool) public delivered;
 
-    // The default post dispatch hook, used for post processing of opting-in dispatches.
-    IPostDispatchHook public defaultHook;
-
-    // The required post dispatch hook, used for post processing of ALL dispatches.
-    IPostDispatchHook public requiredHook;
+    // ============ Upgrade Gap ============
 
-    // Mapping of message ID to delivery context that processed the message.
-    struct Delivery {
-        address processor;
-        uint48 blockNumber;
-    }
-    mapping(bytes32 => Delivery) internal deliveries;
+    // gap for upgrade safety
+    uint256[47] private __GAP;
 
     // ============ Events ============
 
@@ -60,40 +58,45 @@ contract Mailbox is IMailbox, Indexed, Versioned, OwnableUpgradeable {
     event DefaultIsmSet(address indexed module);
 
     /**
-     * @notice Emitted when the default hook is updated
-     * @param hook The new default hook
+     * @notice Emitted when Mailbox is paused
      */
-    event DefaultHookSet(address indexed hook);
+    event Paused();
 
     /**
-     * @notice Emitted when the required hook is updated
-     * @param hook The new required hook
+     * @notice Emitted when Mailbox is unpaused
      */
-    event RequiredHookSet(address indexed hook);
+    event Unpaused();
 
     // ============ Constructor ============
+
     constructor(uint32 _localDomain) {
         localDomain = _localDomain;
     }
 
     // ============ Initializers ============
-    function initialize(
-        address _owner,
-        address _defaultIsm,
-        address _defaultHook,
-        address _requiredHook
-    ) external initializer {
+
+    function initialize(address _owner, address _defaultIsm)
+        external
+        initializer
+    {
+        __PausableReentrancyGuard_init();
         __Ownable_init();
-        setDefaultIsm(_defaultIsm);
-        setDefaultHook(_defaultHook);
-        setRequiredHook(_requiredHook);
         transferOwnership(_owner);
+        _setDefaultIsm(_defaultIsm);
     }
 
     // ============ External Functions ============
+
     /**
-     * @notice Dispatches a message to the destination domain & recipient
-     * using the default hook and empty metadata.
+     * @notice Sets the default ISM for the Mailbox.
+     * @param _module The new default ISM. Must be a contract.
+     */
+    function setDefaultIsm(address _module) external onlyOwner {
+        _setDefaultIsm(_module);
+    }
+
+    /**
+     * @notice Dispatches a message to the destination domain & recipient.
      * @param _destinationDomain Domain of destination chain
      * @param _recipientAddress Address of recipient on destination chain as bytes32
      * @param _messageBody Raw bytes content of message body
@@ -103,86 +106,30 @@ contract Mailbox is IMailbox, Indexed, Versioned, OwnableUpgradeable {
         uint32 _destinationDomain,
         bytes32 _recipientAddress,
         bytes calldata _messageBody
-    ) external payable override returns (bytes32) {
-        return
-            dispatch(
-                _destinationDomain,
-                _recipientAddress,
-                _messageBody,
-                _messageBody[0:0],
-                defaultHook
-            );
-    }
-
-    /**
-     * @notice Dispatches a message to the destination domain & recipient.
-     * @param destinationDomain Domain of destination chain
-     * @param recipientAddress Address of recipient on destination chain as bytes32
-     * @param messageBody Raw bytes content of message body
-     * @param hookMetadata Metadata used by the post dispatch hook
-     * @return The message ID inserted into the Mailbox's merkle tree
-     */
-    function dispatch(
-        uint32 destinationDomain,
-        bytes32 recipientAddress,
-        bytes calldata messageBody,
-        bytes calldata hookMetadata
-    ) external payable override returns (bytes32) {
-        return
-            dispatch(
-                destinationDomain,
-                recipientAddress,
-                messageBody,
-                hookMetadata,
-                defaultHook
-            );
-    }
-
-    /**
-     * @notice Computes quote for dipatching a message to the destination domain & recipient
-     * using the default hook and empty metadata.
-     * @param destinationDomain Domain of destination chain
-     * @param recipientAddress Address of recipient on destination chain as bytes32
-     * @param messageBody Raw bytes content of message body
-     * @return fee The payment required to dispatch the message
-     */
-    function quoteDispatch(
-        uint32 destinationDomain,
-        bytes32 recipientAddress,
-        bytes calldata messageBody
-    ) external view returns (uint256 fee) {
-        return
-            quoteDispatch(
-                destinationDomain,
-                recipientAddress,
-                messageBody,
-                messageBody[0:0],
-                defaultHook
-            );
-    }
+    ) external override notPaused returns (bytes32) {
+        require(_messageBody.length <= MAX_MESSAGE_BODY_BYTES, "msg too long");
+        // Format the message into packed bytes.
+        bytes memory _message = Message.formatMessage(
+            VERSION,
+            count(),
+            localDomain,
+            msg.sender.addressToBytes32(),
+            _destinationDomain,
+            _recipientAddress,
+            _messageBody
+        );
 
-    /**
-     * @notice Computes quote for dispatching a message to the destination domain & recipient.
-     * @param destinationDomain Domain of destination chain
-     * @param recipientAddress Address of recipient on destination chain as bytes32
-     * @param messageBody Raw bytes content of message body
-     * @param defaultHookMetadata Metadata used by the default post dispatch hook
-     * @return fee The payment required to dispatch the message
-     */
-    function quoteDispatch(
-        uint32 destinationDomain,
-        bytes32 recipientAddress,
-        bytes calldata messageBody,
-        bytes calldata defaultHookMetadata
-    ) external view returns (uint256 fee) {
-        return
-            quoteDispatch(
-                destinationDomain,
-                recipientAddress,
-                messageBody,
-                defaultHookMetadata,
-                defaultHook
-            );
+        // Insert the message ID into the merkle tree.
+        bytes32 _id = _message.id();
+        tree.insert(_id);
+        emit Dispatch(
+            msg.sender,
+            _destinationDomain,
+            _recipientAddress,
+            _message
+        );
+        emit DispatchId(_id);
+        return _id;
     }
 
     /**
@@ -193,196 +140,82 @@ contract Mailbox is IMailbox, Indexed, Versioned, OwnableUpgradeable {
      */
     function process(bytes calldata _metadata, bytes calldata _message)
         external
-        payable
         override
+        nonReentrantAndNotPaused
     {
-        /// CHECKS ///
-
         // Check that the message was intended for this mailbox.
-        require(_message.version() == VERSION, "Mailbox: bad version");
-        require(
-            _message.destination() == localDomain,
-            "Mailbox: unexpected destination"
-        );
+        require(_message.version() == VERSION, "!version");
+        require(_message.destination() == localDomain, "!destination");
 
         // Check that the message hasn't already been delivered.
         bytes32 _id = _message.id();
-        require(delivered(_id) == false, "Mailbox: already delivered");
-
-        // Get the recipient's ISM.
-        address recipient = _message.recipientAddress();
-        IInterchainSecurityModule ism = recipientIsm(recipient);
-
-        /// EFFECTS ///
+        require(delivered[_id] == false, "delivered");
+        delivered[_id] = true;
 
-        deliveries[_id] = Delivery({
-            processor: msg.sender,
-            blockNumber: uint48(block.number)
-        });
-        emit Process(_message.origin(), _message.sender(), recipient);
-        emit ProcessId(_id);
-
-        /// INTERACTIONS ///
-
-        // Verify the message via the interchain security module.
-        require(
-            ism.verify(_metadata, _message),
-            "Mailbox: ISM verification failed"
+        // Verify the message via the ISM.
+        IInterchainSecurityModule _ism = IInterchainSecurityModule(
+            recipientIsm(_message.recipientAddress())
         );
+        require(_ism.verify(_metadata, _message), "!module");
 
         // Deliver the message to the recipient.
-        IMessageRecipient(recipient).handle{value: msg.value}(
-            _message.origin(),
-            _message.sender(),
-            _message.body()
-        );
-    }
-
-    /**
-     * @notice Returns the account that processed the message.
-     * @param _id The message ID to check.
-     * @return The account that processed the message.
-     */
-    function processor(bytes32 _id) external view returns (address) {
-        return deliveries[_id].processor;
-    }
-
-    /**
-     * @notice Returns the account that processed the message.
-     * @param _id The message ID to check.
-     * @return The number of the block that the message was processed at.
-     */
-    function processedAt(bytes32 _id) external view returns (uint48) {
-        return deliveries[_id].blockNumber;
+        uint32 origin = _message.origin();
+        bytes32 sender = _message.sender();
+        address recipient = _message.recipientAddress();
+        IMessageRecipient(recipient).handle(origin, sender, _message.body());
+        emit Process(origin, sender, recipient);
+        emit ProcessId(_id);
     }
 
     // ============ Public Functions ============
 
     /**
-     * @notice Dispatches a message to the destination domain & recipient.
-     * @param destinationDomain Domain of destination chain
-     * @param recipientAddress Address of recipient on destination chain as bytes32
-     * @param messageBody Raw bytes content of message body
-     * @param metadata Metadata used by the post dispatch hook
-     * @param hook Custom hook to use instead of the default
-     * @return The message ID inserted into the Mailbox's merkle tree
+     * @notice Calculates and returns tree's current root
      */
-    function dispatch(
-        uint32 destinationDomain,
-        bytes32 recipientAddress,
-        bytes calldata messageBody,
-        bytes calldata metadata,
-        IPostDispatchHook hook
-    ) public payable virtual returns (bytes32) {
-        if (address(hook) == address(0)) {
-            hook = defaultHook;
-        }
-
-        /// CHECKS ///
-
-        // Format the message into packed bytes.
-        bytes memory message = _buildMessage(
-            destinationDomain,
-            recipientAddress,
-            messageBody
-        );
-        bytes32 id = message.id();
-
-        /// EFFECTS ///
-
-        latestDispatchedId = id;
-        nonce += 1;
-        emit Dispatch(msg.sender, destinationDomain, recipientAddress, message);
-        emit DispatchId(id);
-
-        /// INTERACTIONS ///
-        uint256 requiredValue = requiredHook.quoteDispatch(metadata, message);
-        // if underpaying, defer to required hook's reverting behavior
-        if (msg.value < requiredValue) {
-            requiredValue = msg.value;
-        }
-        requiredHook.postDispatch{value: requiredValue}(metadata, message);
-        hook.postDispatch{value: msg.value - requiredValue}(metadata, message);
-
-        return id;
+    function root() public view returns (bytes32) {
+        return tree.root();
     }
 
     /**
-     * @notice Computes quote for dispatching a message to the destination domain & recipient.
-     * @param destinationDomain Domain of destination chain
-     * @param recipientAddress Address of recipient on destination chain as bytes32
-     * @param messageBody Raw bytes content of message body
-     * @param metadata Metadata used by the post dispatch hook
-     * @param hook Custom hook to use instead of the default
-     * @return fee The payment required to dispatch the message
+     * @notice Returns the number of inserted leaves in the tree
      */
-    function quoteDispatch(
-        uint32 destinationDomain,
-        bytes32 recipientAddress,
-        bytes calldata messageBody,
-        bytes calldata metadata,
-        IPostDispatchHook hook
-    ) public view returns (uint256 fee) {
-        if (address(hook) == address(0)) {
-            hook = defaultHook;
-        }
-
-        bytes memory message = _buildMessage(
-            destinationDomain,
-            recipientAddress,
-            messageBody
-        );
-        return
-            requiredHook.quoteDispatch(metadata, message) +
-            hook.quoteDispatch(metadata, message);
+    function count() public view returns (uint32) {
+        // count cannot exceed 2**TREE_DEPTH, see MerkleLib.sol
+        return uint32(tree.count);
     }
 
     /**
-     * @notice Returns true if the message has been processed.
-     * @param _id The message ID to check.
-     * @return True if the message has been delivered.
+     * @notice Returns a checkpoint representing the current merkle tree.
+     * @return root The root of the Mailbox's merkle tree.
+     * @return index The index of the last element in the tree.
      */
-    function delivered(bytes32 _id) public view override returns (bool) {
-        return deliveries[_id].blockNumber > 0;
+    function latestCheckpoint() external view returns (bytes32, uint32) {
+        return (root(), count() - 1);
     }
 
     /**
-     * @notice Sets the default ISM for the Mailbox.
-     * @param _module The new default ISM. Must be a contract.
+     * @notice Pauses mailbox and prevents further dispatch/process calls
+     * @dev Only `owner` can pause the mailbox.
      */
-    function setDefaultIsm(address _module) public onlyOwner {
-        require(
-            Address.isContract(_module),
-            "Mailbox: default ISM not contract"
-        );
-        defaultIsm = IInterchainSecurityModule(_module);
-        emit DefaultIsmSet(_module);
+    function pause() external onlyOwner {
+        _pause();
+        emit Paused();
     }
 
     /**
-     * @notice Sets the default post dispatch hook for the Mailbox.
-     * @param _hook The new default post dispatch hook. Must be a contract.
+     * @notice Unpauses mailbox and allows for message processing.
+     * @dev Only `owner` can unpause the mailbox.
      */
-    function setDefaultHook(address _hook) public onlyOwner {
-        require(
-            Address.isContract(_hook),
-            "Mailbox: default hook not contract"
-        );
-        defaultHook = IPostDispatchHook(_hook);
-        emit DefaultHookSet(_hook);
+    function unpause() external onlyOwner {
+        _unpause();
+        emit Unpaused();
     }
 
     /**
-     * @notice Sets the required post dispatch hook for the Mailbox.
-     * @param _hook The new default post dispatch hook. Must be a contract.
+     * @notice Returns whether mailbox is paused.
      */
-    function setRequiredHook(address _hook) public onlyOwner {
-        require(
-            Address.isContract(_hook),
-            "Mailbox: required hook not contract"
-        );
-        requiredHook = IPostDispatchHook(_hook);
-        emit RequiredHookSet(_hook);
+    function isPaused() external view returns (bool) {
+        return _isPaused();
     }
 
     /**
@@ -396,41 +229,32 @@ contract Mailbox is IMailbox, Indexed, Versioned, OwnableUpgradeable {
         view
         returns (IInterchainSecurityModule)
     {
-        // use low-level staticcall in case of revert or empty return data
-        (bool success, bytes memory returnData) = _recipient.staticcall(
-            abi.encodeCall(
-                ISpecifiesInterchainSecurityModule.interchainSecurityModule,
-                ()
-            )
-        );
-        // check if call was successful and returned data
-        if (success && returnData.length != 0) {
-            // check if returnData is a valid address
-            address ism = abi.decode(returnData, (address));
-            // check if the ISM is a contract
-            if (ism != address(0)) {
-                return IInterchainSecurityModule(ism);
+        // Use a default interchainSecurityModule if one is not specified by the
+        // recipient.
+        // This is useful for backwards compatibility and for convenience as
+        // recipients are not mandated to specify an ISM.
+        try
+            ISpecifiesInterchainSecurityModule(_recipient)
+                .interchainSecurityModule()
+        returns (IInterchainSecurityModule _val) {
+            // If the recipient specifies a zero address, use the default ISM.
+            if (address(_val) != address(0)) {
+                return _val;
             }
-        }
-        // Use the default if a valid one is not specified by the recipient.
+            // solhint-disable-next-line no-empty-blocks
+        } catch {}
         return defaultIsm;
     }
 
     // ============ Internal Functions ============
-    function _buildMessage(
-        uint32 destinationDomain,
-        bytes32 recipientAddress,
-        bytes calldata messageBody
-    ) internal view returns (bytes memory) {
-        return
-            Message.formatMessage(
-                VERSION,
-                nonce,
-                localDomain,
-                msg.sender.addressToBytes32(),
-                destinationDomain,
-                recipientAddress,
-                messageBody
-            );
+
+    /**
+     * @notice Sets the default ISM for the Mailbox.
+     * @param _module The new default ISM. Must be a contract.
+     */
+    function _setDefaultIsm(address _module) internal {
+        require(Address.isContract(_module), "!contract");
+        defaultIsm = IInterchainSecurityModule(_module);
+        emit DefaultIsmSet(_module);
     }
 }

package/contracts/OwnableMulticall.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.13;
+
+// ============ Internal Imports ============
+import {CallLib} from "./libs/Call.sol";
+
+/*
+ * @title OwnableMulticall
+ * @dev Permits immutable owner address to execute calls with value to other contracts.
+ */
+contract OwnableMulticall {
+    address public immutable owner;
+
+    constructor(address _owner) {
+        owner = _owner;
+    }
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "!owner");
+        _;
+    }
+
+    function multicall(CallLib.Call[] calldata calls) external onlyOwner {
+        return CallLib.multicall(calls);
+    }
+
+    // solhint-disable-next-line no-empty-blocks
+    receive() external payable {}
+}

package/contracts/PausableReentrancyGuard.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+
+// adapted from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+abstract contract PausableReentrancyGuardUpgradeable is Initializable {
+    uint256 private constant _ENTERED = 0;
+    uint256 private constant _NOT_ENTERED = 1;
+    uint256 private constant _PAUSED = 2;
+
+    uint256 private _status;
+
+    /**
+     * @dev MUST be called for `nonReentrant` to not always revert
+     */
+    function __PausableReentrancyGuard_init() internal onlyInitializing {
+        _status = _NOT_ENTERED;
+    }
+
+    function _isPaused() internal view returns (bool) {
+        return _status == _PAUSED;
+    }
+
+    function _pause() internal notPaused {
+        _status = _PAUSED;
+    }
+
+    function _unpause() internal {
+        require(_isPaused(), "!paused");
+        _status = _NOT_ENTERED;
+    }
+
+    /**
+     * @dev Prevents a contract from being entered when paused.
+     */
+    modifier notPaused() {
+        require(!_isPaused(), "paused");
+        _;
+    }
+
+    /**
+     * @dev Prevents a contract from calling itself, directly or indirectly.
+     * Calling a `nonReentrant` function from another `nonReentrant`
+     * function is not supported. It is possible to prevent this from happening
+     * by making the `nonReentrant` function external, and making it call a
+     * `private` function that does the actual work.
+     */
+    modifier nonReentrantAndNotPaused() {
+        // status must have been initialized
+        require(_status == _NOT_ENTERED, "reentrant call (or paused)");
+
+        // Any calls to nonReentrant after this point will fail
+        _status = _ENTERED;
+
+        _;
+
+        // By storing the original value once again, a refund is triggered (see
+        // https://eips.ethereum.org/EIPS/eip-2200)
+        _status = _NOT_ENTERED;
+    }
+
+    /**
+     * @dev This empty reserved space is put in place to allow future versions to add new
+     * variables without shifting down storage in the inheritance chain.
+     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
+     */
+    uint256[49] private __gap;
+}