@hyperlane-xyz/core 0.5.4-2 → 0.5.5

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

@@ -3,35 +3,30 @@ pragma solidity >=0.6.11;
 
 // ============ Internal Imports ============
 import {IInterchainGasPaymaster} from "../interfaces/IInterchainGasPaymaster.sol";
-import {ISpecifiesInterchainSecurityModule, IInterchainSecurityModule} from "../interfaces/IInterchainSecurityModule.sol";
-import {IMailbox} from "../interfaces/IMailbox.sol";
+import {IOutbox} from "../interfaces/IOutbox.sol";
+import {IAbacusConnectionManager} from "../interfaces/IAbacusConnectionManager.sol";
 
 // ============ External Imports ============
 import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
-import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 
-abstract contract HyperlaneConnectionClient is
-    OwnableUpgradeable,
-    ISpecifiesInterchainSecurityModule
-{
+abstract contract AbacusConnectionClient is OwnableUpgradeable {
     // ============ Mutable Storage ============
 
-    IMailbox public mailbox;
+    IAbacusConnectionManager public abacusConnectionManager;
     // Interchain Gas Paymaster contract. The relayer associated with this contract
     // must be willing to relay messages dispatched from the current Outbox 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 mailbox is set.
-     * @param mailbox The address of the mailbox contract
+     * @notice Emitted when a new abacusConnectionManager is set.
+     * @param abacusConnectionManager The address of the abacusConnectionManager contract
      */
-    event MailboxSet(address indexed mailbox);
+    event AbacusConnectionManagerSet(address indexed abacusConnectionManager);
 
     /**
      * @notice Emitted when a new Interchain Gas Paymaster is set.
@@ -39,64 +34,45 @@ abstract contract HyperlaneConnectionClient is
      */
     event InterchainGasPaymasterSet(address indexed interchainGasPaymaster);
 
-    event InterchainSecurityModuleSet(address indexed module);
-
     // ============ Modifiers ============
 
     /**
-     * @notice Only accept messages from an Hyperlane Mailbox contract
+     * @notice Only accept messages from an Abacus Inbox contract
      */
-    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");
+    modifier onlyInbox() {
+        require(_isInbox(msg.sender), "!inbox");
         _;
     }
 
     // ======== Initializer =========
 
-    function __HyperlaneConnectionClient_initialize(address _mailbox)
-        internal
-        onlyInitializing
-    {
-        _setMailbox(_mailbox);
+    function __AbacusConnectionClient_initialize(
+        address _abacusConnectionManager
+    ) internal onlyInitializing {
+        _setAbacusConnectionManager(_abacusConnectionManager);
         __Ownable_init();
     }
 
-    function __HyperlaneConnectionClient_initialize(
-        address _mailbox,
+    function __AbacusConnectionClient_initialize(
+        address _abacusConnectionManager,
         address _interchainGasPaymaster
     ) internal onlyInitializing {
         _setInterchainGasPaymaster(_interchainGasPaymaster);
-        __HyperlaneConnectionClient_initialize(_mailbox);
-    }
-
-    function __HyperlaneConnectionClient_initialize(
-        address _mailbox,
-        address _interchainGasPaymaster,
-        address _interchainSecurityModule
-    ) internal onlyInitializing {
-        _setInterchainSecurityModule(_interchainSecurityModule);
-        __HyperlaneConnectionClient_initialize(
-            _mailbox,
-            _interchainGasPaymaster
-        );
+        __AbacusConnectionClient_initialize(_abacusConnectionManager);
     }
 
     // ============ External functions ============
 
     /**
-     * @notice Sets the address of the application's Mailbox.
-     * @param _mailbox The address of the Mailbox contract.
+     * @notice Sets the address of the application's AbacusConnectionManager.
+     * @param _abacusConnectionManager The address of the AbacusConnectionManager contract.
      */
-    function setMailbox(address _mailbox) external virtual onlyOwner {
-        _setMailbox(_mailbox);
+    function setAbacusConnectionManager(address _abacusConnectionManager)
+        external
+        virtual
+        onlyOwner
+    {
+        _setAbacusConnectionManager(_abacusConnectionManager);
     }
 
     /**
@@ -111,14 +87,6 @@ abstract contract HyperlaneConnectionClient is
         _setInterchainGasPaymaster(_interchainGasPaymaster);
     }
 
-    function setInterchainSecurityModule(address _module)
-        external
-        virtual
-        onlyOwner
-    {
-        _setInterchainSecurityModule(_module);
-    }
-
     // ============ Internal functions ============
 
     /**
@@ -127,7 +95,6 @@ abstract contract HyperlaneConnectionClient is
      */
     function _setInterchainGasPaymaster(address _interchainGasPaymaster)
         internal
-        onlyContract(_interchainGasPaymaster)
     {
         interchainGasPaymaster = IInterchainGasPaymaster(
             _interchainGasPaymaster
@@ -137,18 +104,38 @@ abstract contract HyperlaneConnectionClient is
 
     /**
      * @notice Modify the contract the Application uses to validate Inbox contracts
-     * @param _mailbox The address of the mailbox contract
+     * @param _abacusConnectionManager The address of the abacusConnectionManager contract
      */
-    function _setMailbox(address _mailbox) internal onlyContract(_mailbox) {
-        mailbox = IMailbox(_mailbox);
-        emit MailboxSet(_mailbox);
-    }
-
-    function _setInterchainSecurityModule(address _module)
+    function _setAbacusConnectionManager(address _abacusConnectionManager)
         internal
-        onlyContract(_module)
     {
-        interchainSecurityModule = IInterchainSecurityModule(_module);
-        emit InterchainSecurityModuleSet(_module);
+        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
+     */
+    function _isInbox(address _potentialInbox) internal view returns (bool) {
+        return abacusConnectionManager.isInbox(_potentialInbox);
+    }
+
+    /**
+     * @notice Get the local domain from the abacusConnectionManager
+     * @return The local domain
+     */
+    function _localDomain() internal view virtual returns (uint32) {
+        return abacusConnectionManager.localDomain();
     }
 }

package/contracts/AbacusConnectionManager.sol

@@ -0,0 +1,145 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+pragma abicoder v2;
+
+// ============ Internal Imports ============
+import {IOutbox} from "../interfaces/IOutbox.sol";
+import {IAbacusConnectionManager} from "../interfaces/IAbacusConnectionManager.sol";
+
+// ============ External Imports ============
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+/**
+ * @title AbacusConnectionManager
+ * @author Celo Labs Inc.
+ * @notice Manages a registry of local Inbox contracts for remote Outbox
+ * domains.
+ */
+contract AbacusConnectionManager is IAbacusConnectionManager, Ownable {
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    // ============ Public Storage ============
+
+    // Outbox contract
+    IOutbox public override outbox;
+    // local Inbox address => remote Outbox domain
+    mapping(address => uint32) public inboxToDomain;
+    // remote Outbox domain => local Inbox addresses
+    mapping(uint32 => EnumerableSet.AddressSet) domainToInboxes;
+
+    // ============ Events ============
+
+    /**
+     * @notice Emitted when a new Outbox is set.
+     * @param outbox the address of the Outbox
+     */
+    event OutboxSet(address indexed outbox);
+
+    /**
+     * @notice Emitted when a new Inbox is enrolled / added
+     * @param domain the remote domain of the Outbox contract for the Inbox
+     * @param inbox the address of the Inbox
+     */
+    event InboxEnrolled(uint32 indexed domain, address inbox);
+
+    /**
+     * @notice Emitted when a new Inbox is un-enrolled / removed
+     * @param domain the remote domain of the Outbox contract for the Inbox
+     * @param inbox the address of the Inbox
+     */
+    event InboxUnenrolled(uint32 indexed domain, address inbox);
+
+    // ============ Constructor ============
+
+    // solhint-disable-next-line no-empty-blocks
+    constructor() Ownable() {}
+
+    // ============ External Functions ============
+
+    /**
+     * @notice Sets the address of the local Outbox contract.
+     * @param _outbox The address of the new local Outbox contract.
+     */
+    function setOutbox(address _outbox) external onlyOwner {
+        require(Address.isContract(_outbox), "outbox !contract");
+        outbox = IOutbox(_outbox);
+        emit OutboxSet(_outbox);
+    }
+
+    /**
+     * @notice Allow Owner to enroll Inbox contract
+     * @param _domain the remote domain of the Outbox contract for the Inbox
+     * @param _inbox the address of the Inbox
+     */
+    function enrollInbox(uint32 _domain, address _inbox) external onlyOwner {
+        require(Address.isContract(_inbox), "inbox !contract");
+        require(!isInbox(_inbox), "already inbox");
+        // add inbox and domain to two-way mapping
+        inboxToDomain[_inbox] = _domain;
+        domainToInboxes[_domain].add(_inbox);
+        emit InboxEnrolled(_domain, _inbox);
+    }
+
+    /**
+     * @notice Allow Owner to un-enroll Inbox contract
+     * @param _inbox the address of the Inbox
+     */
+    function unenrollInbox(address _inbox) external onlyOwner {
+        _unenrollInbox(_inbox);
+    }
+
+    /**
+     * @notice Query local domain from Outbox
+     * @return local domain
+     */
+    function localDomain() external view override returns (uint32) {
+        return outbox.localDomain();
+    }
+
+    /**
+     * @notice Returns the Inbox addresses for a given remote domain
+     * @return inboxes An array of addresses of the Inboxes
+     */
+    function getInboxes(uint32 remoteDomain)
+        external
+        view
+        returns (address[] memory)
+    {
+        EnumerableSet.AddressSet storage _inboxes = domainToInboxes[
+            remoteDomain
+        ];
+        uint256 length = _inboxes.length();
+        address[] memory ret = new address[](length);
+        for (uint256 i = 0; i < length; i += 1) {
+            ret[i] = _inboxes.at(i);
+        }
+        return ret;
+    }
+
+    // ============ Public Functions ============
+
+    /**
+     * @notice Check whether _inbox is enrolled
+     * @param _inbox the inbox to check for enrollment
+     * @return TRUE iff _inbox is enrolled
+     */
+    function isInbox(address _inbox) public view override returns (bool) {
+        return inboxToDomain[_inbox] != 0;
+    }
+
+    // ============ Internal Functions ============
+
+    /**
+     * @notice Remove the inbox from the two-way mappings
+     * @param _inbox inbox to un-enroll
+     */
+    function _unenrollInbox(address _inbox) internal {
+        uint32 _currentDomain = inboxToDomain[_inbox];
+        require(domainToInboxes[_currentDomain].remove(_inbox), "not enrolled");
+        domainToInboxes[_currentDomain].remove(_inbox);
+        inboxToDomain[_inbox] = 0;
+        emit InboxUnenrolled(_currentDomain, _inbox);
+    }
+}

package/contracts/Inbox.sol

@@ -0,0 +1,148 @@
+// 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 {IMessageRecipient} from "../interfaces/IMessageRecipient.sol";
+import {IInbox} from "../interfaces/IInbox.sol";
+
+// ============ External Imports ============
+import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+
+/**
+ * @title Inbox
+ * @author Celo Labs Inc.
+ * @notice Track root updates on Outbox, prove and dispatch messages to end
+ * recipients.
+ */
+contract Inbox is IInbox, ReentrancyGuardUpgradeable, Versioned, Mailbox {
+    // ============ Libraries ============
+
+    using MerkleLib for MerkleLib.Tree;
+    using Message for bytes;
+    using TypeCasts for bytes32;
+
+    // ============ Enums ============
+
+    // Status of Message:
+    //   0 - None - message has not been processed
+    //   1 - Processed - message has been dispatched to recipient
+    enum MessageStatus {
+        None,
+        Processed
+    }
+
+    // ============ Public Storage ============
+
+    // Domain of outbox chain
+    uint32 public override remoteDomain;
+    // Mapping of message leaves to MessageStatus
+    mapping(bytes32 => MessageStatus) public messages;
+
+    // ============ Upgrade Gap ============
+
+    // gap for upgrade safety
+    uint256[48] private __GAP;
+
+    // ============ Events ============
+
+    /**
+     * @notice Emitted when message is processed
+     * @dev This event allows watchers to observe the merkle proof they need
+     * to prove fraud on the Outbox.
+     * @param messageHash Hash of message that was processed.
+     */
+    event Process(bytes32 indexed messageHash);
+
+    // ============ Constructor ============
+
+    // solhint-disable-next-line no-empty-blocks
+    constructor(uint32 _localDomain) Mailbox(_localDomain) {}
+
+    // ============ Initializer ============
+
+    function initialize(uint32 _remoteDomain, address _validatorManager)
+        external
+        initializer
+    {
+        __ReentrancyGuard_init();
+        __Mailbox_initialize(_validatorManager);
+        remoteDomain = _remoteDomain;
+    }
+
+    // ============ External Functions ============
+
+    /**
+     * @notice Attempts to process the provided formatted `message`. Performs
+     * verification against root of the proof
+     * @dev Called by the validator manager, which is responsible for verifying a
+     * quorum of validator signatures on the checkpoint.
+     * @dev Reverts if verification of the message fails.
+     * @param _root The merkle root of the checkpoint used to prove message inclusion.
+     * @param _index The index of the checkpoint used to prove message inclusion.
+     * @param _message Formatted message (refer to Mailbox.sol Message library)
+     * @param _proof Merkle proof of inclusion for message's leaf
+     * @param _leafIndex Index of leaf in outbox's merkle tree
+     */
+    function process(
+        bytes32 _root,
+        uint256 _index,
+        bytes calldata _message,
+        bytes32[32] calldata _proof,
+        uint256 _leafIndex
+    ) external override nonReentrant onlyValidatorManager {
+        require(_index >= _leafIndex, "!index");
+        bytes32 _messageHash = _message.leaf(_leafIndex);
+        // ensure that message has not been processed
+        require(
+            messages[_messageHash] == MessageStatus.None,
+            "!MessageStatus.None"
+        );
+        // calculate the expected root based on the proof
+        bytes32 _calculatedRoot = MerkleLib.branchRoot(
+            _messageHash,
+            _proof,
+            _leafIndex
+        );
+        // verify the merkle proof
+        require(_calculatedRoot == _root, "!proof");
+        _process(_message, _messageHash);
+    }
+
+    // ============ Internal Functions ============
+
+    /**
+     * @notice Marks a message as processed and calls handle on the recipient
+     * @dev Internal function that can be called by contracts like TestInbox
+     * @param _message Formatted message (refer to Mailbox.sol Message library)
+     * @param _messageHash keccak256 hash of the message
+     */
+    function _process(bytes calldata _message, bytes32 _messageHash) internal {
+        (
+            uint32 origin,
+            bytes32 sender,
+            uint32 destination,
+            bytes32 recipient,
+            bytes calldata body
+        ) = _message.destructure();
+
+        // ensure message came from the correct domain
+        require(origin == remoteDomain, "!origin");
+        // ensure message was meant for this domain
+        require(destination == localDomain, "!destination");
+
+        // update message status as processed
+        messages[_messageHash] = MessageStatus.Processed;
+
+        IMessageRecipient(recipient.bytes32ToAddress()).handle(
+            origin,
+            sender,
+            body
+        );
+        emit Process(_messageHash);
+    }
+}

package/contracts/InterchainGasPaymaster.sol

@@ -16,10 +16,11 @@ contract InterchainGasPaymaster is IInterchainGasPaymaster, OwnableUpgradeable {
 
     /**
      * @notice Emitted when a payment is made for a message's gas costs.
-     * @param messageId The ID of the message to pay for.
+     * @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.
      */
-    event GasPayment(bytes32 indexed messageId, uint256 amount);
+    event GasPayment(address indexed outbox, uint256 leafIndex, uint256 amount);
 
     // ============ Constructor ============
 
@@ -37,20 +38,21 @@ contract InterchainGasPaymaster is IInterchainGasPaymaster, OwnableUpgradeable {
     /**
      * @notice Deposits msg.value as a payment for the relaying of a message
      * to its destination chain.
-     * @param _messageId The ID of the message to pay for.
+     * @param _outbox The address of the Outbox contract.
+     * @param _leafIndex The index of the message in the Outbox merkle tree.
      * @param _destinationDomain The domain of the message's destination chain.
      */
-    function payGasFor(bytes32 _messageId, uint32 _destinationDomain)
-        external
-        payable
-        override
-    {
+    function payGasFor(
+        address _outbox,
+        uint256 _leafIndex,
+        uint32 _destinationDomain
+    ) 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.
         _destinationDomain;
 
-        emit GasPayment(_messageId, msg.value);
+        emit GasPayment(_outbox, _leafIndex, msg.value);
     }
 
     /**