@hyperlane-xyz/core 0.5.3 → 0.5.4-0

package/interfaces/IInterchainQueryRouter.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.6.11;
+
+import {Call} from "../contracts/Call.sol";
+
+interface IInterchainQueryRouter {
+    function query(
+        uint32 _destinationDomain,
+        Call calldata call,
+        bytes calldata callback
+    ) external returns (bytes32);
+
+    function query(
+        uint32 _destinationDomain,
+        Call[] calldata calls,
+        bytes[] calldata callbacks
+    ) external returns (bytes32);
+}

package/interfaces/IInterchainSecurityModule.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.6.11;
+
+interface IInterchainSecurityModule {
+    // Called by the Mailbox to determine whether or not the message should be accepted.
+    function verify(bytes calldata _metadata, bytes calldata _message)
+        external
+        returns (bool);
+}
+
+interface ISpecifiesInterchainSecurityModule {
+    function interchainSecurityModule()
+        external
+        view
+        returns (IInterchainSecurityModule);
+}

package/interfaces/IMailbox.sol

@@ -1,8 +1,21 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
-pragma solidity >=0.6.11;
+pragma solidity >=0.8.0;
 
 interface IMailbox {
     function localDomain() external view returns (uint32);
 
-    function validatorManager() external view returns (address);
+    function dispatch(
+        uint32 _destinationDomain,
+        bytes32 _recipientAddress,
+        bytes calldata _messageBody
+    ) external returns (bytes32);
+
+    function process(bytes calldata _metadata, bytes calldata _message)
+        external;
+
+    function count() external view returns (uint32);
+
+    function root() external view returns (bytes32);
+
+    function latestCheckpoint() external view returns (bytes32, uint32);
 }

package/interfaces/IMultisigIsm.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.6.0;
+
+import {IInterchainSecurityModule} from "./IInterchainSecurityModule.sol";
+
+interface IMultisigIsm is IInterchainSecurityModule {
+    function isEnrolled(uint32 _domain, address _validator)
+        external
+        view
+        returns (bool);
+
+    function threshold(uint32 _domain) external view returns (uint256);
+
+    function validators(uint32 _domain)
+        external
+        view
+        returns (address[] memory);
+}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@hyperlane-xyz/core",
   "description": "Core solidity contracts for Hyperlane",
-  "version": "0.5.3",
+  "version": "0.5.4-0",
   "dependencies": {
-    "@hyperlane-xyz/utils": "0.5.3",
+    "@hyperlane-xyz/utils": "0.5.4-0",
     "@openzeppelin/contracts": "^4.6.0",
     "@openzeppelin/contracts-upgradeable": "^4.6.0"
   },
@@ -49,5 +49,6 @@
     "prettier": "prettier --write ./contracts ./interfaces ./test",
     "test": "hardhat test"
   },
-  "types": "dist/index.d.ts"
+  "types": "dist/index.d.ts",
+  "stableVersion": "0.5.3"
 }

package/contracts/AbacusConnectionManager.sol

@@ -1,145 +0,0 @@
-// 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

@@ -1,148 +0,0 @@
-// 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/MerkleTreeManager.sol

@@ -1,32 +0,0 @@
-// 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

@@ -1,191 +0,0 @@
-// 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/mock/MockInbox.sol

@@ -1,52 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
-
-import {TypeCasts} from "../libs/TypeCasts.sol";
-import {IMessageRecipient} from "../../interfaces/IMessageRecipient.sol";
-
-contract MockInbox {
-    using TypeCasts for bytes32;
-
-    struct PendingMessage {
-        uint32 originDomain;
-        bytes32 sender;
-        bytes32 recipient;
-        bytes messageBody;
-    }
-
-    mapping(uint256 => PendingMessage) pendingMessages;
-    uint256 totalMessages = 0;
-    uint256 messageProcessed = 0;
-
-    function addPendingMessage(
-        uint32 _originDomain,
-        bytes32 _sender,
-        bytes32 _recipient,
-        bytes memory _messageBody
-    ) external {
-        pendingMessages[totalMessages] = PendingMessage(
-            _originDomain,
-            _sender,
-            _recipient,
-            _messageBody
-        );
-        totalMessages += 1;
-    }
-
-    function processNextPendingMessage() public {
-        PendingMessage memory pendingMessage = pendingMessages[
-            messageProcessed
-        ];
-
-        address recipient = pendingMessage.recipient.bytes32ToAddress();
-
-        IMessageRecipient(recipient).handle(
-            // This is completely arbitrary and consumers should not rely
-            // on domain handling in the mock mailbox contracts.
-            pendingMessage.originDomain,
-            pendingMessage.sender,
-            pendingMessage.messageBody
-        );
-        messageProcessed += 1;
-    }
-}