@hyperlane-xyz/core 0.5.4-2 → 0.5.5

package/contracts/Mailbox.sol

@@ -2,227 +2,92 @@
 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";
-
 // ============ External Imports ============
-import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
-import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
-
-contract Mailbox is
-    IMailbox,
-    OwnableUpgradeable,
-    ReentrancyGuardUpgradeable,
-    Versioned
-{
-    // ============ Libraries ============
-
-    using MerkleLib for MerkleLib.Tree;
-    using Message for bytes;
-    using TypeCasts for bytes32;
-    using TypeCasts for address;
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 
-    // ============ Constants ============
+/**
+ * @title Mailbox
+ * @author Celo Labs Inc.
+ * @notice Shared utilities between Outbox and Inbox.
+ */
+abstract contract Mailbox is IMailbox, OwnableUpgradeable {
+    // ============ Immutable Variables ============
 
-    // 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;
+    uint32 public immutable override localDomain;
 
-    // ============ Public Storage ============
+    // ============ Public Variables ============
 
-    // 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;
+    // Address of the validator manager contract.
+    address public validatorManager;
 
     // ============ Upgrade Gap ============
 
     // gap for upgrade safety
-    uint256[47] private __GAP;
+    uint256[49] private __GAP;
 
     // ============ Events ============
 
     /**
-     * @notice Emitted when the default ISM is updated
-     * @param module The new default ISM
+     * @notice Emitted when the validator manager contract is changed
+     * @param validatorManager The address of the new validatorManager
      */
-    event DefaultIsmSet(address indexed module);
+    event ValidatorManagerSet(address validatorManager);
 
-    /**
-     * @notice Emitted when a new message is dispatched via Hyperlane
-     * @param messageId The unique message identifier
-     * @param message Raw bytes of message
-     */
-    event Dispatch(bytes32 indexed messageId, bytes message);
+    // ============ Modifiers ============
 
     /**
-     * @notice Emitted when a Hyperlane message is delivered
-     * @param messageId The unique message identifier
+     * @notice Ensures that a function is called by the validator manager contract.
      */
-    event Process(bytes32 indexed messageId);
+    modifier onlyValidatorManager() {
+        require(msg.sender == validatorManager, "!validatorManager");
+        _;
+    }
 
     // ============ Constructor ============
 
-    // solhint-disable-next-line no-empty-blocks
     constructor(uint32 _localDomain) {
         localDomain = _localDomain;
     }
 
     // ============ Initializer ============
 
-    function initialize(address _defaultIsm) external initializer {
-        __ReentrancyGuard_init();
+    function __Mailbox_initialize(address _validatorManager)
+        internal
+        onlyInitializing
+    {
+        // initialize owner
         __Ownable_init();
-        _setDefaultIsm(_defaultIsm);
+        _setValidatorManager(_validatorManager);
     }
 
     // ============ External Functions ============
 
     /**
-     * @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
-     * @return The message ID inserted into the Mailbox's merkle tree
+     * @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
      */
-    function dispatch(
-        uint32 _destinationDomain,
-        bytes32 _recipientAddress,
-        bytes calldata _messageBody
-    ) external override 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(_id, _message);
-        return _id;
-    }
-
-    /**
-     * @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 process(bytes calldata _metadata, bytes calldata _message)
-        external
-        override
-        nonReentrant
-    {
-        // 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())
-        );
-        require(_ism.verify(_metadata, _message), "!module");
-
-        // Deliver the message to the recipient.
-        uint32 _origin = _message.origin();
-        IMessageRecipient(_message.recipientAddress()).handle(
-            _origin,
-            _message.sender(),
-            _message.body()
-        );
-        emit Process(_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 Outbox'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);
+    function setValidatorManager(address _validatorManager) external onlyOwner {
+        _setValidatorManager(_validatorManager);
     }
 
     // ============ 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`.
+     * @notice Set the validator manager
+     * @param _validatorManager Address of the validator manager
      */
-    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
-        ) {
-            // TODO: reconsider
-            if (address(_val) != address(0)) {
-                return _val;
-            }
-        } catch {}
-        return defaultIsm;
+    function _setValidatorManager(address _validatorManager) internal {
+        require(
+            Address.isContract(_validatorManager),
+            "!contract validatorManager"
+        );
+        validatorManager = _validatorManager;
+        emit ValidatorManagerSet(_validatorManager);
     }
 }

package/contracts/MerkleTreeManager.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+import {MerkleLib} from "./libs/Merkle.sol";
+
+/**
+ * @title MerkleTreeManager
+ * @author Celo Labs Inc.
+ * @notice Contains a Merkle tree instance and
+ * exposes view functions for the tree.
+ */
+contract MerkleTreeManager {
+    // ============ Libraries ============
+
+    using MerkleLib for MerkleLib.Tree;
+    MerkleLib.Tree public tree;
+
+    // ============ Upgrade Gap ============
+
+    // gap for upgrade safety
+    uint256[49] private __GAP;
+
+    // ============ Public Functions ============
+
+    /**
+     * @notice Calculates and returns tree's current root
+     */
+    function root() public view returns (bytes32) {
+        return tree.root();
+    }
+}

package/contracts/Outbox.sol

@@ -0,0 +1,191 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+import {Versioned} from "./upgrade/Versioned.sol";
+import {Mailbox} from "./Mailbox.sol";
+import {MerkleLib} from "./libs/Merkle.sol";
+import {Message} from "./libs/Message.sol";
+import {TypeCasts} from "./libs/TypeCasts.sol";
+import {MerkleTreeManager} from "./MerkleTreeManager.sol";
+import {IOutbox} from "../interfaces/IOutbox.sol";
+
+/**
+ * @title Outbox
+ * @author Celo Labs Inc.
+ * @notice Accepts messages to be dispatched to remote chains,
+ * constructs a Merkle tree of the messages,
+ * and accepts signatures from a bonded Validator
+ * which notarize the Merkle tree roots.
+ * Accepts submissions of fraudulent signatures
+ * by the Validator and slashes the Validator in this case.
+ */
+contract Outbox is IOutbox, Versioned, MerkleTreeManager, Mailbox {
+    // ============ Libraries ============
+
+    using MerkleLib for MerkleLib.Tree;
+    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;
+
+    // ============ Enums ============
+
+    // States:
+    //   0 - UnInitialized - before initialize function is called
+    //   note: the contract is initialized at deploy time, so it should never be in this state
+    //   1 - Active - as long as the contract has not become fraudulent
+    //   2 - Failed - after a valid fraud proof has been submitted;
+    //   contract will no longer accept updates or new messages
+    enum States {
+        UnInitialized,
+        Active,
+        Failed
+    }
+
+    // ============ Public Storage Variables ============
+
+    // Cached checkpoints, mapping root => leaf index.
+    // Cached checkpoints must have index > 0 as the presence of such
+    // a checkpoint cannot be distinguished from its absence.
+    mapping(bytes32 => uint256) public cachedCheckpoints;
+    // The latest cached root
+    bytes32 public latestCachedRoot;
+    // Current state of contract
+    States public state;
+
+    // ============ Upgrade Gap ============
+
+    // gap for upgrade safety
+    uint256[47] private __GAP;
+
+    // ============ Events ============
+
+    /**
+     * @notice Emitted when a checkpoint is cached.
+     * @param root Merkle root
+     * @param index Leaf index
+     */
+    event CheckpointCached(bytes32 indexed root, uint256 indexed index);
+
+    /**
+     * @notice Emitted when a new message is dispatched via Abacus
+     * @param leafIndex Index of message's leaf in merkle tree
+     * @param message Raw bytes of message
+     */
+    event Dispatch(uint256 indexed leafIndex, bytes message);
+
+    event Fail();
+
+    // ============ Constructor ============
+
+    constructor(uint32 _localDomain) Mailbox(_localDomain) {} // solhint-disable-line no-empty-blocks
+
+    // ============ Initializer ============
+
+    function initialize(address _validatorManager) external initializer {
+        __Mailbox_initialize(_validatorManager);
+        state = States.Active;
+    }
+
+    // ============ Modifiers ============
+
+    /**
+     * @notice Ensures that contract state != FAILED when the function is called
+     */
+    modifier notFailed() {
+        require(state != States.Failed, "failed state");
+        _;
+    }
+
+    // ============ External Functions  ============
+
+    /**
+     * @notice Dispatch the message it to the destination domain & recipient
+     * @dev Format the message, insert its hash into Merkle tree,
+     * and emit `Dispatch` event with message information.
+     * @param _destinationDomain Domain of destination chain
+     * @param _recipientAddress Address of recipient on destination chain as bytes32
+     * @param _messageBody Raw bytes content of message
+     * @return The leaf index of the dispatched message's hash in the Merkle tree.
+     */
+    function dispatch(
+        uint32 _destinationDomain,
+        bytes32 _recipientAddress,
+        bytes calldata _messageBody
+    ) external override notFailed returns (uint256) {
+        require(_messageBody.length <= MAX_MESSAGE_BODY_BYTES, "msg too long");
+        // The leaf has not been inserted yet at this point
+        uint256 _leafIndex = count();
+        // format the message into packed bytes
+        bytes memory _message = Message.formatMessage(
+            localDomain,
+            msg.sender.addressToBytes32(),
+            _destinationDomain,
+            _recipientAddress,
+            _messageBody
+        );
+        // insert the hashed message into the Merkle tree
+        bytes32 _messageHash = keccak256(
+            abi.encodePacked(_message, _leafIndex)
+        );
+        tree.insert(_messageHash);
+        emit Dispatch(_leafIndex, _message);
+        return _leafIndex;
+    }
+
+    /**
+     * @notice Caches the current merkle root and index.
+     * @dev emits CheckpointCached event
+     */
+    function cacheCheckpoint() external override notFailed {
+        (bytes32 _root, uint256 _index) = latestCheckpoint();
+        require(_index > 0, "!index");
+        cachedCheckpoints[_root] = _index;
+        latestCachedRoot = _root;
+        emit CheckpointCached(_root, _index);
+    }
+
+    /**
+     * @notice Set contract state to FAILED.
+     * @dev Called by the validator manager when fraud is proven.
+     */
+    function fail() external override onlyValidatorManager {
+        // set contract to FAILED
+        state = States.Failed;
+        emit Fail();
+    }
+
+    /**
+     * @notice Returns the latest entry in the checkpoint cache.
+     * @return root Latest cached root
+     * @return index Latest cached index
+     */
+    function latestCachedCheckpoint()
+        external
+        view
+        returns (bytes32 root, uint256 index)
+    {
+        root = latestCachedRoot;
+        index = cachedCheckpoints[root];
+    }
+
+    /**
+     * @notice Returns the number of inserted leaves in the tree
+     */
+    function count() public view returns (uint256) {
+        return tree.count;
+    }
+
+    /**
+     * @notice Returns a checkpoint representing the current merkle tree.
+     * @return root The root of the Outbox's merkle tree.
+     * @return index The index of the last element in the tree.
+     */
+    function latestCheckpoint() public view returns (bytes32, uint256) {
+        return (root(), count() - 1);
+    }
+}

package/contracts/Router.sol

@@ -2,12 +2,13 @@
 pragma solidity >=0.6.11;
 
 // ============ Internal Imports ============
-import {HyperlaneConnectionClient} from "./HyperlaneConnectionClient.sol";
+import {AbacusConnectionClient} from "./AbacusConnectionClient.sol";
+import {IAbacusConnectionManager} from "../interfaces/IAbacusConnectionManager.sol";
 import {IInterchainGasPaymaster} from "../interfaces/IInterchainGasPaymaster.sol";
 import {IMessageRecipient} from "../interfaces/IMessageRecipient.sol";
-import {IMailbox} from "../interfaces/IMailbox.sol";
+import {IOutbox} from "../interfaces/IOutbox.sol";
 
-abstract contract Router is HyperlaneConnectionClient, IMessageRecipient {
+abstract contract Router is AbacusConnectionClient, IMessageRecipient {
     string constant NO_ROUTER_ENROLLED_REVERT_MESSAGE =
         "No router enrolled for domain. Did you specify the right domain ID?";
 
@@ -40,16 +41,19 @@ abstract contract Router is HyperlaneConnectionClient, IMessageRecipient {
     }
 
     // ======== Initializer =========
-    function __Router_initialize(address _mailbox) internal onlyInitializing {
-        __HyperlaneConnectionClient_initialize(_mailbox);
+    function __Router_initialize(address _abacusConnectionManager)
+        internal
+        onlyInitializing
+    {
+        __AbacusConnectionClient_initialize(_abacusConnectionManager);
     }
 
     function __Router_initialize(
-        address _mailbox,
+        address _abacusConnectionManager,
         address _interchainGasPaymaster
     ) internal onlyInitializing {
-        __HyperlaneConnectionClient_initialize(
-            _mailbox,
+        __AbacusConnectionClient_initialize(
+            _abacusConnectionManager,
             _interchainGasPaymaster
         );
     }
@@ -69,21 +73,6 @@ abstract contract Router is HyperlaneConnectionClient, IMessageRecipient {
         _enrollRemoteRouter(_domain, _router);
     }
 
-    /**
-     * @notice Batch version of `enrollRemoteRouter`
-     * @param _domains The domaisn of the remote Application Routers
-     * @param _routers The addresses of the remote Application Routers
-     */
-    function enrollRemoteRouters(
-        uint32[] calldata _domains,
-        bytes32[] calldata _routers
-    ) external virtual onlyOwner {
-        require(_domains.length == _routers.length, "!length");
-        for (uint256 i = 0; i < _domains.length; i += 1) {
-            _enrollRemoteRouter(_domains[i], _routers[i]);
-        }
-    }
-
     /**
      * @notice Handles an incoming message
      * @param _origin The origin domain
@@ -94,7 +83,7 @@ abstract contract Router is HyperlaneConnectionClient, IMessageRecipient {
         uint32 _origin,
         bytes32 _sender,
         bytes calldata _message
-    ) external virtual override onlyMailbox onlyRemoteRouter(_origin, _sender) {
+    ) external virtual override onlyInbox onlyRemoteRouter(_origin, _sender) {
         // TODO: callbacks on success/failure
         _handle(_origin, _sender, _message);
     }
@@ -146,40 +135,60 @@ abstract contract Router is HyperlaneConnectionClient, IMessageRecipient {
     }
 
     /**
-     * @notice Dispatches a message to an enrolled router via the local router's Mailbox
+     * @notice Dispatches a message to an enrolled router via the local router's Outbox.
+     * @notice Does not pay interchain gas.
+     * @dev Reverts if there is no enrolled router for _destinationDomain.
+     * @param _destinationDomain The domain of the chain to which to send the message.
+     * @param _msg The message to dispatch.
+     */
+    function _dispatch(uint32 _destinationDomain, bytes memory _msg)
+        internal
+        returns (uint256)
+    {
+        return _dispatch(_outbox(), _destinationDomain, _msg);
+    }
+
+    /**
+     * @notice Dispatches a message to an enrolled router via the local router's Outbox
      * and pays for it to be relayed to the destination.
      * @dev Reverts if there is no enrolled router for _destinationDomain.
      * @param _destinationDomain The domain of the chain to which to send the message.
-     * @param _messageBody Raw bytes content of message.
+     * @param _msg The message to dispatch.
      * @param _gasPayment The amount of native tokens to pay for the message to be relayed.
      */
     function _dispatchWithGas(
         uint32 _destinationDomain,
-        bytes memory _messageBody,
+        bytes memory _msg,
         uint256 _gasPayment
     ) internal {
-        bytes32 _messageId = _dispatch(_destinationDomain, _messageBody);
+        IOutbox _outbox = _outbox();
+        uint256 _leafIndex = _dispatch(_outbox, _destinationDomain, _msg);
         if (_gasPayment > 0) {
             interchainGasPaymaster.payGasFor{value: _gasPayment}(
-                _messageId,
+                address(_outbox),
+                _leafIndex,
                 _destinationDomain
             );
         }
     }
 
+    // ============ Private functions ============
+
     /**
-     * @notice Dispatches a message to an enrolled router via the provided Mailbox.
+     * @notice Dispatches a message to an enrolled router via the provided Outbox.
      * @dev Does not pay interchain gas.
      * @dev Reverts if there is no enrolled router for _destinationDomain.
+     * @param _outbox The outbox contract to dispatch the message through.
      * @param _destinationDomain The domain of the chain to which to send the message.
-     * @param _messageBody Raw bytes content of message.
+     * @param _msg The message to dispatch.
      */
-    function _dispatch(uint32 _destinationDomain, bytes memory _messageBody)
-        internal
-        returns (bytes32)
-    {
+    function _dispatch(
+        IOutbox _outbox,
+        uint32 _destinationDomain,
+        bytes memory _msg
+    ) private returns (uint256) {
         // Ensure that destination chain has an enrolled router.
         bytes32 _router = _mustHaveRemoteRouter(_destinationDomain);
-        return mailbox.dispatch(_destinationDomain, _router, _messageBody);
+        return _outbox.dispatch(_destinationDomain, _router, _msg);
     }
 }