@hyperlane-xyz/core 0.5.5 → 1.0.0-beta0

package/contracts/{AbacusConnectionClient.sol → HyperlaneConnectionClient.sol}

@@ -3,30 +3,35 @@ pragma solidity >=0.6.11;
 
 // ============ Internal Imports ============
 import {IInterchainGasPaymaster} from "../interfaces/IInterchainGasPaymaster.sol";
-import {IOutbox} from "../interfaces/IOutbox.sol";
-import {IAbacusConnectionManager} from "../interfaces/IAbacusConnectionManager.sol";
+import {ISpecifiesInterchainSecurityModule, IInterchainSecurityModule} from "../interfaces/IInterchainSecurityModule.sol";
+import {IMailbox} from "../interfaces/IMailbox.sol";
 
 // ============ External Imports ============
 import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 
-abstract contract AbacusConnectionClient is OwnableUpgradeable {
+abstract contract HyperlaneConnectionClient is
+    OwnableUpgradeable,
+    ISpecifiesInterchainSecurityModule
+{
     // ============ Mutable Storage ============
 
-    IAbacusConnectionManager public abacusConnectionManager;
+    IMailbox public mailbox;
     // Interchain Gas Paymaster contract. The relayer associated with this contract
-    // must be willing to relay messages dispatched from the current Outbox contract,
+    // must be willing to relay messages dispatched from the current Mailbox contract,
     // otherwise payments made to the paymaster will not result in relayed messages.
     IInterchainGasPaymaster public interchainGasPaymaster;
 
+    IInterchainSecurityModule public interchainSecurityModule;
+
     uint256[48] private __GAP; // gap for upgrade safety
 
     // ============ Events ============
-
     /**
-     * @notice Emitted when a new abacusConnectionManager is set.
-     * @param abacusConnectionManager The address of the abacusConnectionManager contract
+     * @notice Emitted when a new mailbox is set.
+     * @param mailbox The address of the mailbox contract
      */
-    event AbacusConnectionManagerSet(address indexed abacusConnectionManager);
+    event MailboxSet(address indexed mailbox);
 
     /**
      * @notice Emitted when a new Interchain Gas Paymaster is set.
@@ -34,45 +39,64 @@ abstract contract AbacusConnectionClient is OwnableUpgradeable {
      */
     event InterchainGasPaymasterSet(address indexed interchainGasPaymaster);
 
+    event InterchainSecurityModuleSet(address indexed module);
+
     // ============ Modifiers ============
 
     /**
-     * @notice Only accept messages from an Abacus Inbox contract
+     * @notice Only accept messages from an Hyperlane Mailbox contract
      */
-    modifier onlyInbox() {
-        require(_isInbox(msg.sender), "!inbox");
+    modifier onlyMailbox() {
+        require(msg.sender == address(mailbox), "!mailbox");
+        _;
+    }
+
+    /**
+     * @notice Only accept addresses that at least have contract code
+     */
+    modifier onlyContract(address _contract) {
+        require(Address.isContract(_contract), "!contract");
         _;
     }
 
     // ======== Initializer =========
 
-    function __AbacusConnectionClient_initialize(
-        address _abacusConnectionManager
-    ) internal onlyInitializing {
-        _setAbacusConnectionManager(_abacusConnectionManager);
+    function __HyperlaneConnectionClient_initialize(address _mailbox)
+        internal
+        onlyInitializing
+    {
+        _setMailbox(_mailbox);
         __Ownable_init();
     }
 
-    function __AbacusConnectionClient_initialize(
-        address _abacusConnectionManager,
+    function __HyperlaneConnectionClient_initialize(
+        address _mailbox,
         address _interchainGasPaymaster
     ) internal onlyInitializing {
         _setInterchainGasPaymaster(_interchainGasPaymaster);
-        __AbacusConnectionClient_initialize(_abacusConnectionManager);
+        __HyperlaneConnectionClient_initialize(_mailbox);
+    }
+
+    function __HyperlaneConnectionClient_initialize(
+        address _mailbox,
+        address _interchainGasPaymaster,
+        address _interchainSecurityModule
+    ) internal onlyInitializing {
+        _setInterchainSecurityModule(_interchainSecurityModule);
+        __HyperlaneConnectionClient_initialize(
+            _mailbox,
+            _interchainGasPaymaster
+        );
     }
 
     // ============ External functions ============
 
     /**
-     * @notice Sets the address of the application's AbacusConnectionManager.
-     * @param _abacusConnectionManager The address of the AbacusConnectionManager contract.
+     * @notice Sets the address of the application's Mailbox.
+     * @param _mailbox The address of the Mailbox contract.
      */
-    function setAbacusConnectionManager(address _abacusConnectionManager)
-        external
-        virtual
-        onlyOwner
-    {
-        _setAbacusConnectionManager(_abacusConnectionManager);
+    function setMailbox(address _mailbox) external virtual onlyOwner {
+        _setMailbox(_mailbox);
     }
 
     /**
@@ -87,6 +111,14 @@ abstract contract AbacusConnectionClient is OwnableUpgradeable {
         _setInterchainGasPaymaster(_interchainGasPaymaster);
     }
 
+    function setInterchainSecurityModule(address _module)
+        external
+        virtual
+        onlyOwner
+    {
+        _setInterchainSecurityModule(_module);
+    }
+
     // ============ Internal functions ============
 
     /**
@@ -95,6 +127,7 @@ abstract contract AbacusConnectionClient is OwnableUpgradeable {
      */
     function _setInterchainGasPaymaster(address _interchainGasPaymaster)
         internal
+        onlyContract(_interchainGasPaymaster)
     {
         interchainGasPaymaster = IInterchainGasPaymaster(
             _interchainGasPaymaster
@@ -103,39 +136,19 @@ abstract contract AbacusConnectionClient is OwnableUpgradeable {
     }
 
     /**
-     * @notice Modify the contract the Application uses to validate Inbox contracts
-     * @param _abacusConnectionManager The address of the abacusConnectionManager contract
-     */
-    function _setAbacusConnectionManager(address _abacusConnectionManager)
-        internal
-    {
-        abacusConnectionManager = IAbacusConnectionManager(
-            _abacusConnectionManager
-        );
-        emit AbacusConnectionManagerSet(_abacusConnectionManager);
-    }
-
-    /**
-     * @notice Get the local Outbox contract from the abacusConnectionManager
-     * @return The local Outbox contract
-     */
-    function _outbox() internal view returns (IOutbox) {
-        return abacusConnectionManager.outbox();
-    }
-
-    /**
-     * @notice Determine whether _potentialInbox is an enrolled Inbox from the abacusConnectionManager
-     * @return True if _potentialInbox is an enrolled Inbox
+     * @notice Modify the contract the Application uses to validate Mailbox contracts
+     * @param _mailbox The address of the mailbox contract
      */
-    function _isInbox(address _potentialInbox) internal view returns (bool) {
-        return abacusConnectionManager.isInbox(_potentialInbox);
+    function _setMailbox(address _mailbox) internal onlyContract(_mailbox) {
+        mailbox = IMailbox(_mailbox);
+        emit MailboxSet(_mailbox);
     }
 
-    /**
-     * @notice Get the local domain from the abacusConnectionManager
-     * @return The local domain
-     */
-    function _localDomain() internal view virtual returns (uint32) {
-        return abacusConnectionManager.localDomain();
+    function _setInterchainSecurityModule(address _module)
+        internal
+        onlyContract(_module)
+    {
+        interchainSecurityModule = IInterchainSecurityModule(_module);
+        emit InterchainSecurityModuleSet(_module);
     }
 }

package/contracts/InterchainGasPaymaster.sol

@@ -16,11 +16,15 @@ contract InterchainGasPaymaster is IInterchainGasPaymaster, OwnableUpgradeable {
 
     /**
      * @notice Emitted when a payment is made for a message's gas costs.
-     * @param outbox The address of the Outbox contract.
-     * @param leafIndex The index of the message in the Outbox merkle tree.
-     * @param amount The amount of native tokens paid.
+     * @param messageId The ID of the message to pay for.
+     * @param gasAmount The amount of destination gas paid for.
+     * @param payment The amount of native tokens paid.
      */
-    event GasPayment(address indexed outbox, uint256 leafIndex, uint256 amount);
+    event GasPayment(
+        bytes32 indexed messageId,
+        uint256 gasAmount,
+        uint256 payment
+    );
 
     // ============ Constructor ============
 
@@ -38,21 +42,24 @@ contract InterchainGasPaymaster is IInterchainGasPaymaster, OwnableUpgradeable {
     /**
      * @notice Deposits msg.value as a payment for the relaying of a message
      * to its destination chain.
-     * @param _outbox The address of the Outbox contract.
-     * @param _leafIndex The index of the message in the Outbox merkle tree.
+     * @param _messageId The ID of the message to pay for.
      * @param _destinationDomain The domain of the message's destination chain.
+     * @param _gasAmount The amount of destination gas to pay for. Currently unused.
+     * @param _refundAddress The address to refund any overpayment to. Currently unused.
      */
-    function payGasFor(
-        address _outbox,
-        uint256 _leafIndex,
-        uint32 _destinationDomain
+    function payForGas(
+        bytes32 _messageId,
+        uint32 _destinationDomain,
+        uint256 _gasAmount,
+        address _refundAddress
     ) external payable override {
         // Silence compiler warning. The NatSpec @param requires the parameter to be named.
-        // While not used at the moment, future versions of the paymaster may conditionally
-        // forward payments depending on the destination domain.
+        // While not used at the moment, future versions of the paymaster have behavior specific
+        // to the destination domain and refund overpayments to the _refundAddress.
         _destinationDomain;
+        _refundAddress;
 
-        emit GasPayment(_outbox, _leafIndex, msg.value);
+        emit GasPayment(_messageId, _gasAmount, msg.value);
     }
 
     /**

package/contracts/Mailbox.sol

@@ -2,92 +2,292 @@
 pragma solidity >=0.8.0;
 
 // ============ Internal Imports ============
+import {Versioned} from "./upgrade/Versioned.sol";
+import {MerkleLib} from "./libs/Merkle.sol";
+import {Message} from "./libs/Message.sol";
+import {TypeCasts} from "./libs/TypeCasts.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 {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+
+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;
 
-/**
- * @title Mailbox
- * @author Celo Labs Inc.
- * @notice Shared utilities between Outbox and Inbox.
- */
-abstract contract Mailbox is IMailbox, OwnableUpgradeable {
-    // ============ Immutable Variables ============
+    // ============ 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 override localDomain;
+    uint32 public immutable localDomain;
 
-    // ============ Public Variables ============
+    // ============ Public Storage ============
 
-    // Address of the validator manager contract.
-    address public validatorManager;
+    // 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;
 
     // ============ Upgrade Gap ============
 
     // gap for upgrade safety
-    uint256[49] private __GAP;
+    uint256[47] private __GAP;
 
     // ============ Events ============
 
     /**
-     * @notice Emitted when the validator manager contract is changed
-     * @param validatorManager The address of the new validatorManager
+     * @notice Emitted when the default ISM is updated
+     * @param module The new default ISM
      */
-    event ValidatorManagerSet(address validatorManager);
+    event DefaultIsmSet(address indexed module);
 
-    // ============ Modifiers ============
+    /**
+     * @notice Emitted when a new message is dispatched via Hyperlane
+     * @param sender The address that dispatched the message
+     * @param destination The destination domain of the message
+     * @param recipient The message recipient address on `destination`
+     * @param message Raw bytes of message
+     */
+    event Dispatch(
+        address indexed sender,
+        uint32 indexed destination,
+        bytes32 indexed recipient,
+        bytes message
+    );
 
     /**
-     * @notice Ensures that a function is called by the validator manager contract.
+     * @notice Emitted when a new message is dispatched via Hyperlane
+     * @param messageId The unique message identifier
      */
-    modifier onlyValidatorManager() {
-        require(msg.sender == validatorManager, "!validatorManager");
-        _;
-    }
+    event DispatchId(bytes32 indexed messageId);
+
+    /**
+     * @notice Emitted when a Hyperlane message is processed
+     * @param messageId The unique message identifier
+     */
+    event ProcessId(bytes32 indexed messageId);
+
+    /**
+     * @notice Emitted when a Hyperlane message is delivered
+     * @param origin The origin domain of the message
+     * @param sender The message sender address on `origin`
+     * @param recipient The address that handled the message
+     */
+    event Process(
+        uint32 indexed origin,
+        bytes32 indexed sender,
+        address indexed recipient
+    );
+
+    /**
+     * @notice Emitted when Mailbox is paused
+     */
+    event Paused();
+
+    /**
+     * @notice Emitted when Mailbox is unpaused
+     */
+    event Unpaused();
 
     // ============ Constructor ============
 
+    // solhint-disable-next-line no-empty-blocks
     constructor(uint32 _localDomain) {
         localDomain = _localDomain;
     }
 
     // ============ Initializer ============
 
-    function __Mailbox_initialize(address _validatorManager)
-        internal
-        onlyInitializing
-    {
-        // initialize owner
+    function initialize(address _defaultIsm) external initializer {
+        __PausableReentrancyGuard_init();
         __Ownable_init();
-        _setValidatorManager(_validatorManager);
+        _setDefaultIsm(_defaultIsm);
     }
 
     // ============ External Functions ============
 
     /**
-     * @notice Set a new validator manager contract
-     * @dev Mailbox(es) will initially be initialized using a trusted validator manager contract;
-     * we will progressively decentralize by swapping the trusted contract with a new implementation
-     * that implements Validator bonding & slashing, and rules for Validator selection & rotation
-     * @param _validatorManager the new validator manager contract
+     * @notice Sets the default ISM for the Mailbox.
+     * @param _module The new default ISM. Must be a contract.
      */
-    function setValidatorManager(address _validatorManager) external onlyOwner {
-        _setValidatorManager(_validatorManager);
+    function setDefaultIsm(address _module) external onlyOwner {
+        _setDefaultIsm(_module);
     }
 
-    // ============ Internal 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
+     * @return The message ID inserted into the Mailbox's merkle tree
+     */
+    function dispatch(
+        uint32 _destinationDomain,
+        bytes32 _recipientAddress,
+        bytes calldata _messageBody
+    ) 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
+        );
+
+        // 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;
+    }
 
     /**
-     * @notice Set the validator manager
-     * @param _validatorManager Address of the validator manager
+     * @notice Attempts to deliver `_message` to its recipient. Verifies
+     * `_message` via the recipient's ISM using the provided `_metadata`.
+     * @param _metadata Metadata used by the ISM to verify `_message`.
+     * @param _message Formatted Hyperlane message (refer to Message.sol).
      */
-    function _setValidatorManager(address _validatorManager) internal {
-        require(
-            Address.isContract(_validatorManager),
-            "!contract validatorManager"
+    function process(bytes calldata _metadata, bytes calldata _message)
+        external
+        override
+        nonReentrantAndNotPaused
+    {
+        // Check that the message was intended for this mailbox.
+        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, "delivered");
+        delivered[_id] = true;
+
+        // Verify the message via the ISM.
+        IInterchainSecurityModule _ism = _recipientIsm(
+            ISpecifiesInterchainSecurityModule(_message.recipientAddress())
         );
-        validatorManager = _validatorManager;
-        emit ValidatorManagerSet(_validatorManager);
+        require(_ism.verify(_metadata, _message), "!module");
+
+        // Deliver the message to the recipient.
+        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 Calculates and returns tree's current root
+     */
+    function root() public view returns (bytes32) {
+        return tree.root();
+    }
+
+    /**
+     * @notice Returns the number of inserted leaves in the tree
+     */
+    function count() public view returns (uint32) {
+        // count cannot exceed 2**TREE_DEPTH, see MerkleLib.sol
+        return uint32(tree.count);
+    }
+
+    /**
+     * @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 latestCheckpoint() public view returns (bytes32, uint32) {
+        return (root(), count() - 1);
+    }
+
+    /**
+     * @notice Pauses mailbox and prevents further dispatch/process calls
+     * @dev Only `owner` can pause the mailbox.
+     */
+    function pause() external onlyOwner {
+        _pause();
+        emit Paused();
+    }
+
+    /**
+     * @notice Unpauses mailbox and allows for message processing.
+     * @dev Only `owner` can unpause the mailbox.
+     */
+    function unpause() external onlyOwner {
+        _unpause();
+        emit Unpaused();
+    }
+
+    /**
+     * @notice Returns whether mailbox is paused.
+     */
+    function isPaused() external view returns (bool) {
+        return _isPaused();
+    }
+
+    // ============ Internal Functions ============
+
+    /**
+     * @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);
+    }
+
+    /**
+     * @notice Returns the ISM to use for the recipient, defaulting to the
+     * default ISM if none is specified.
+     * @param _recipient The message recipient whose ISM should be returned.
+     * @return The ISM to use for `_recipient`.
+     */
+    function _recipientIsm(ISpecifiesInterchainSecurityModule _recipient)
+        internal
+        view
+        returns (IInterchainSecurityModule)
+    {
+        // 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 _recipient.interchainSecurityModule() returns (
+            IInterchainSecurityModule _val
+        ) {
+            // If the recipient specifies a zero address, use the default ISM.
+            if (address(_val) != address(0)) {
+                return _val;
+            }
+        } catch {}
+        return defaultIsm;
     }
 }

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 _NOT_ENTERED = 1;
+    uint256 private constant _ENTERED = 2;
+    uint256 private constant _PAUSED = 3;
+
+    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;
+}