@hyperlane-xyz/core 0.5.4-2 → 0.5.5

package/contracts/mock/MockHyperlaneEnvironment.sol

@@ -1,7 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.13;
 
-import "./MockMailbox.sol";
+import "./MockOutbox.sol";
+import "./MockInbox.sol";
+import "../AbacusConnectionManager.sol";
 import "../middleware/InterchainQueryRouter.sol";
 
 import {TypeCasts} from "../libs/TypeCasts.sol";
@@ -10,30 +12,57 @@ contract MockHyperlaneEnvironment {
     uint32 originDomain;
     uint32 destinationDomain;
 
-    mapping(uint32 => MockMailbox) public mailboxes;
+    mapping(uint32 => MockOutbox) public outboxes;
+    mapping(uint32 => MockInbox) public inboxes;
+    mapping(uint32 => AbacusConnectionManager) public connectionManagers;
     mapping(uint32 => InterchainQueryRouter) public queryRouters;
 
     constructor(uint32 _originDomain, uint32 _destinationDomain) {
         originDomain = _originDomain;
         destinationDomain = _destinationDomain;
 
-        MockMailbox originMailbox = new MockMailbox(_originDomain);
-        MockMailbox destinationMailbox = new MockMailbox(_destinationDomain);
+        MockInbox originInbox = new MockInbox();
+        MockOutbox originOutbox = new MockOutbox(
+            _originDomain,
+            address(originInbox)
+        );
+
+        MockInbox destinationInbox = new MockInbox();
+        MockOutbox destinationOutbox = new MockOutbox(
+            _destinationDomain,
+            address(destinationInbox)
+        );
+
+        outboxes[_originDomain] = originOutbox;
+        outboxes[_destinationDomain] = destinationOutbox;
+        inboxes[_originDomain] = destinationInbox;
+        inboxes[_destinationDomain] = originInbox;
 
-        mailboxes[_originDomain] = originMailbox;
-        mailboxes[_destinationDomain] = destinationMailbox;
+        AbacusConnectionManager originManager = new AbacusConnectionManager();
+        AbacusConnectionManager destinationManager = new AbacusConnectionManager();
+
+        originManager.setOutbox(address(originOutbox));
+        destinationManager.enrollInbox(
+            _destinationDomain,
+            address(originInbox)
+        );
+        destinationManager.setOutbox(address(destinationOutbox));
+        originManager.enrollInbox(_originDomain, address(destinationInbox));
+
+        connectionManagers[_originDomain] = originManager;
+        connectionManagers[_destinationDomain] = destinationManager;
 
         InterchainQueryRouter originQueryRouter = new InterchainQueryRouter();
         InterchainQueryRouter destinationQueryRouter = new InterchainQueryRouter();
 
         originQueryRouter.initialize(
             address(this),
-            address(originMailbox),
+            address(originManager),
             address(0)
         );
         destinationQueryRouter.initialize(
             address(this),
-            address(destinationMailbox),
+            address(destinationManager),
             address(0)
         );
 
@@ -50,11 +79,19 @@ contract MockHyperlaneEnvironment {
         queryRouters[_destinationDomain] = destinationQueryRouter;
     }
 
+    function connectionManager(uint32 _domain)
+        public
+        view
+        returns (AbacusConnectionManager)
+    {
+        return connectionManagers[_domain];
+    }
+
     function processNextPendingMessage() public {
-        mailboxes[destinationDomain].processNextInboundMessage();
+        inboxes[destinationDomain].processNextPendingMessage();
     }
 
     function processNextPendingMessageFromDestination() public {
-        mailboxes[originDomain].processNextInboundMessage();
+        inboxes[originDomain].processNextPendingMessage();
     }
 }

package/contracts/mock/MockInbox.sol

@@ -0,0 +1,52 @@
+// 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;
+    }
+}

package/contracts/mock/MockInterchainAccountRouter.sol

@@ -38,17 +38,31 @@ contract MockInterchainAccountRouter is IInterchainAccountRouter {
         originDomain = _originDomain;
     }
 
-    function dispatch(uint32, Call[] calldata calls)
-        external
-        returns (bytes32)
+    function dispatch(uint32 _destinationDomain, Call[] calldata calls)
+        public
+        returns (uint256)
     {
+        return _dispatch(_destinationDomain, calls);
+    }
+
+    function dispatch(
+        uint32 _destinationDomain,
+        address target,
+        bytes calldata data
+    ) external returns (uint256) {
+        Call[] memory calls = new Call[](1);
+        calls[0] = Call({to: target, data: data});
+        return _dispatch(_destinationDomain, calls);
+    }
+
+    function _dispatch(uint32, Call[] memory calls) internal returns (uint256) {
         pendingCalls[totalCalls] = PendingCall(
             originDomain,
             msg.sender,
             abi.encode(calls)
         );
         totalCalls += 1;
-        return keccak256(abi.encodePacked(totalCalls));
+        return totalCalls;
     }
 
     function getInterchainAccount(uint32 _origin, address _sender)

package/contracts/mock/MockOutbox.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {MockInbox} from "./MockInbox.sol";
+import {TypeCasts} from "../libs/TypeCasts.sol";
+
+contract MockOutbox {
+    MockInbox inbox;
+    uint32 domain;
+    using TypeCasts for address;
+
+    constructor(uint32 _domain, address _inbox) {
+        domain = _domain;
+        inbox = MockInbox(_inbox);
+    }
+
+    function dispatch(
+        uint32,
+        bytes32 _recipientAddress,
+        bytes calldata _messageBody
+    ) external returns (uint256) {
+        inbox.addPendingMessage(
+            domain,
+            msg.sender.addressToBytes32(),
+            _recipientAddress,
+            _messageBody
+        );
+        return 1;
+    }
+}

package/contracts/mock/MockPortalBridge.sol

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.13;
+
+import {IPortalTokenBridge} from "../middleware/liquidity-layer/interfaces/portal/IPortalTokenBridge.sol";
+import {MockToken} from "./MockToken.sol";
+import {TypeCasts} from "../libs/TypeCasts.sol";
+
+contract MockPortalBridge is IPortalTokenBridge {
+    uint256 nextNonce = 0;
+    MockToken token;
+
+    constructor(MockToken _token) {
+        token = _token;
+    }
+
+    function transferTokensWithPayload(
+        address,
+        uint256 amount,
+        uint16,
+        bytes32,
+        uint32,
+        bytes memory
+    ) external payable returns (uint64 sequence) {
+        nextNonce = nextNonce + 1;
+        token.transferFrom(msg.sender, address(this), amount);
+        token.burn(amount);
+        return uint64(nextNonce);
+    }
+
+    function wrappedAsset(uint16, bytes32) external view returns (address) {
+        return address(token);
+    }
+
+    function isWrappedAsset(address) external pure returns (bool) {
+        return true;
+    }
+
+    function completeTransferWithPayload(bytes memory encodedVm)
+        external
+        returns (bytes memory)
+    {
+        (uint32 _originDomain, uint224 _nonce, uint256 _amount) = abi.decode(
+            encodedVm,
+            (uint32, uint224, uint256)
+        );
+
+        token.mint(msg.sender, _amount);
+        // Format it so that parseTransferWithPayload returns the desired payload
+        return
+            abi.encode(
+                TypeCasts.addressToBytes32(address(token)),
+                adapterData(_originDomain, _nonce, address(token))
+            );
+    }
+
+    function parseTransferWithPayload(bytes memory encoded)
+        external
+        pure
+        returns (TransferWithPayload memory transfer)
+    {
+        (bytes32 tokenAddress, bytes memory payload) = abi.decode(
+            encoded,
+            (bytes32, bytes)
+        );
+        transfer.payload = payload;
+        transfer.tokenAddress = tokenAddress;
+    }
+
+    function adapterData(
+        uint32 _originDomain,
+        uint224 _nonce,
+        address _token
+    ) public pure returns (bytes memory) {
+        return
+            abi.encode(
+                _originDomain,
+                _nonce,
+                TypeCasts.addressToBytes32(_token)
+            );
+    }
+
+    function mockPortalVaa(
+        uint32 _originDomain,
+        uint224 _nonce,
+        uint256 _amount
+    ) public pure returns (bytes memory) {
+        return abi.encode(_originDomain, _nonce, _amount);
+    }
+}

package/contracts/test/TestAbacusConnectionClient.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.6.11;
+import {IOutbox} from "../../interfaces/IOutbox.sol";
+
+import "../AbacusConnectionClient.sol";
+
+contract TestAbacusConnectionClient is AbacusConnectionClient {
+    function initialize(address _abacusConnectionManager) external initializer {
+        __AbacusConnectionClient_initialize(_abacusConnectionManager);
+    }
+
+    function outbox() external view returns (IOutbox) {
+        return _outbox();
+    }
+
+    function isInbox(address _potentialInbox) external view returns (bool) {
+        return _isInbox(_potentialInbox);
+    }
+
+    function localDomain() external view returns (uint32) {
+        return _localDomain();
+    }
+}

package/contracts/test/TestInbox.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import "../Inbox.sol";
+
+contract TestInbox is Inbox {
+    using Message for bytes32;
+    using TypeCasts for bytes32;
+
+    constructor(uint32 _localDomain) Inbox(_localDomain) {} // solhint-disable-line no-empty-blocks
+
+    function testBranchRoot(
+        bytes32 leaf,
+        bytes32[32] calldata proof,
+        uint256 index
+    ) external pure returns (bytes32) {
+        return MerkleLib.branchRoot(leaf, proof, index);
+    }
+
+    function testProcess(bytes calldata _message, uint256 leafIndex) external {
+        bytes32 _messageHash = keccak256(abi.encodePacked(_message, leafIndex));
+        _process(_message, _messageHash);
+    }
+
+    function testHandle(
+        uint32 origin,
+        bytes32 sender,
+        bytes32 recipient,
+        bytes calldata body
+    ) external {
+        IMessageRecipient(recipient.bytes32ToAddress()).handle(
+            origin,
+            sender,
+            body
+        );
+    }
+
+    function setMessageStatus(bytes32 _leaf, MessageStatus status) external {
+        messages[_leaf] = status;
+    }
+
+    function getRevertMsg(bytes calldata _res)
+        internal
+        pure
+        returns (string memory)
+    {
+        // If the _res length is less than 68, then the transaction failed
+        // silently (without a revert message)
+        if (_res.length < 68) return "Transaction reverted silently";
+
+        // Remove the selector (first 4 bytes) and decode revert string
+        return abi.decode(_res[4:], (string));
+    }
+}

package/contracts/test/TestMailbox.sol

@@ -1,42 +1,12 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 pragma solidity >=0.8.0;
 
-import {Mailbox} from "../Mailbox.sol";
-import {TypeCasts} from "../libs/TypeCasts.sol";
-import {MerkleLib} from "../libs/Merkle.sol";
-import {IMessageRecipient} from "../../interfaces/IMessageRecipient.sol";
+import "../Mailbox.sol";
 
 contract TestMailbox is Mailbox {
-    using TypeCasts for bytes32;
+    constructor(uint32 _localDomain) Mailbox(_localDomain) {}
 
-    constructor(uint32 _localDomain) Mailbox(_localDomain) {} // solhint-disable-line no-empty-blocks
-
-    function proof() external view returns (bytes32[32] memory) {
-        bytes32[32] memory _zeroes = MerkleLib.zeroHashes();
-        uint256 _index = tree.count - 1;
-        bytes32[32] memory _proof;
-
-        for (uint256 i = 0; i < 32; i++) {
-            uint256 _ithBit = (_index >> i) & 0x01;
-            if (_ithBit == 1) {
-                _proof[i] = tree.branch[i];
-            } else {
-                _proof[i] = _zeroes[i];
-            }
-        }
-        return _proof;
-    }
-
-    function testHandle(
-        uint32 _origin,
-        bytes32 _sender,
-        bytes32 _recipient,
-        bytes calldata _body
-    ) external {
-        IMessageRecipient(_recipient.bytes32ToAddress()).handle(
-            _origin,
-            _sender,
-            _body
-        );
+    function initialize(address _validatorManager) external initializer {
+        __Mailbox_initialize(_validatorManager);
     }
 }

package/contracts/test/TestMerkle.sol

@@ -1,14 +1,13 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 pragma solidity >=0.8.0;
-import {MerkleLib} from "../libs/Merkle.sol";
 
-contract TestMerkle {
-    using MerkleLib for MerkleLib.Tree;
+import "../MerkleTreeManager.sol";
 
-    MerkleLib.Tree public tree;
+contract TestMerkle is MerkleTreeManager {
+    using MerkleLib for MerkleLib.Tree;
 
     // solhint-disable-next-line no-empty-blocks
-    constructor() {}
+    constructor() MerkleTreeManager() {}
 
     function insert(bytes32 _node) external {
         tree.insert(_node);
@@ -28,8 +27,4 @@ contract TestMerkle {
     function count() public view returns (uint256) {
         return tree.count;
     }
-
-    function root() public view returns (bytes32) {
-        return tree.root();
-    }
 }

package/contracts/test/TestMessage.sol

@@ -6,28 +6,12 @@ import {Message} from "../libs/Message.sol";
 contract TestMessage {
     using Message for bytes;
 
-    function version(bytes calldata _message)
-        external
-        pure
-        returns (uint32 _version)
-    {
-        return _message.version();
-    }
-
-    function nonce(bytes calldata _message)
-        external
-        pure
-        returns (uint256 _nonce)
-    {
-        return _message.nonce();
-    }
-
     function body(bytes calldata _message)
         external
         pure
         returns (bytes calldata _body)
     {
-        return _message.body();
+        (, , , , _body) = _message.destructure();
     }
 
     function origin(bytes calldata _message)
@@ -35,7 +19,7 @@ contract TestMessage {
         pure
         returns (uint32 _origin)
     {
-        return _message.origin();
+        (_origin, , , , ) = _message.destructure();
     }
 
     function sender(bytes calldata _message)
@@ -43,7 +27,7 @@ contract TestMessage {
         pure
         returns (bytes32 _sender)
     {
-        return _message.sender();
+        (, _sender, , , ) = _message.destructure();
     }
 
     function destination(bytes calldata _message)
@@ -51,7 +35,7 @@ contract TestMessage {
         pure
         returns (uint32 _destination)
     {
-        return _message.destination();
+        (, , _destination, , ) = _message.destructure();
     }
 
     function recipient(bytes calldata _message)
@@ -59,7 +43,7 @@ contract TestMessage {
         pure
         returns (bytes32 _recipient)
     {
-        return _message.recipient();
+        (, , , _recipient, ) = _message.destructure();
     }
 
     function recipientAddress(bytes calldata _message)
@@ -67,10 +51,14 @@ contract TestMessage {
         pure
         returns (address _recipient)
     {
-        return _message.recipientAddress();
+        (, , , _recipient, ) = _message.destructureAddresses();
     }
 
-    function id(bytes calldata _message) external pure returns (bytes32) {
-        return _message.id();
+    function leaf(bytes calldata _message, uint256 _leafIndex)
+        external
+        pure
+        returns (bytes32)
+    {
+        return _message.leaf(_leafIndex);
     }
 }

package/contracts/test/TestMultisigValidatorManager.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {MultisigValidatorManager} from "../validator-manager/MultisigValidatorManager.sol";
+
+/**
+ * This contract exists to test MultisigValidatorManager.sol, which is abstract
+ * and cannot be deployed directly.
+ */
+contract TestMultisigValidatorManager is MultisigValidatorManager {
+    // solhint-disable-next-line no-empty-blocks
+    constructor(
+        uint32 _domain,
+        address[] memory _validators,
+        uint256 _threshold
+    ) MultisigValidatorManager(_domain, _validators, _threshold) {}
+
+    /**
+     * @notice Hash of domain concatenated with "ABACUS".
+     * @dev This is a public getter of _domainHash to test with.
+     * @param _domain The domain to hash.
+     */
+    function getDomainHash(uint32 _domain) external pure returns (bytes32) {
+        return _domainHash(_domain);
+    }
+}

package/contracts/test/TestOutbox.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+import "../Outbox.sol";
+import {MerkleLib} from "../libs/Merkle.sol";
+
+contract TestOutbox is Outbox {
+    constructor(uint32 _localDomain) Outbox(_localDomain) {} // solhint-disable-line no-empty-blocks
+
+    /**
+     * @notice Set the validator manager
+     * @param _validatorManager Address of the validator manager
+     */
+    function testSetValidatorManager(address _validatorManager) external {
+        validatorManager = _validatorManager;
+    }
+
+    function proof() external view returns (bytes32[32] memory) {
+        bytes32[32] memory _zeroes = MerkleLib.zeroHashes();
+        uint256 _index = tree.count - 1;
+        bytes32[32] memory _proof;
+
+        for (uint256 i = 0; i < 32; i++) {
+            uint256 _ithBit = (_index >> i) & 0x01;
+            if (_ithBit == 1) {
+                _proof[i] = tree.branch[i];
+            } else {
+                _proof[i] = _zeroes[i];
+            }
+        }
+        return _proof;
+    }
+
+    function branch() external view returns (bytes32[32] memory) {
+        return tree.branch;
+    }
+
+    function branchRoot(
+        bytes32 _item,
+        bytes32[32] memory _branch,
+        uint256 _index
+    ) external pure returns (bytes32) {
+        return MerkleLib.branchRoot(_item, _branch, _index);
+    }
+}

package/contracts/test/TestSendReceiver.sol

@@ -5,7 +5,7 @@ import {TypeCasts} from "../libs/TypeCasts.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";
 
 contract TestSendReceiver is IMessageRecipient {
     using TypeCasts for address;
@@ -13,12 +13,12 @@ contract TestSendReceiver is IMessageRecipient {
     event Handled(bytes32 blockHash);
 
     function dispatchToSelf(
-        IMailbox _outbox,
+        IOutbox _outbox,
         IInterchainGasPaymaster _paymaster,
         uint32 _destinationDomain,
         bytes calldata _messageBody
     ) external payable {
-        bytes32 _messageId = _outbox.dispatch(
+        uint256 _leafIndex = _outbox.dispatch(
             _destinationDomain,
             address(this).addressToBytes32(),
             _messageBody
@@ -28,14 +28,23 @@ contract TestSendReceiver is IMessageRecipient {
         if (_blockHashNum % 5 == 0) {
             // Pay in two separate calls, resulting in 2 distinct events
             uint256 _half = _value / 2;
-            _paymaster.payGasFor{value: _half}(_messageId, _destinationDomain);
+            _paymaster.payGasFor{value: _half}(
+                address(_outbox),
+                _leafIndex,
+                _destinationDomain
+            );
             _paymaster.payGasFor{value: _value - _half}(
-                _messageId,
+                address(_outbox),
+                _leafIndex,
                 _destinationDomain
             );
         } else {
             // Pay the entire msg.value in one call
-            _paymaster.payGasFor{value: _value}(_messageId, _destinationDomain);
+            _paymaster.payGasFor{value: _value}(
+                address(_outbox),
+                _leafIndex,
+                _destinationDomain
+            );
         }
     }
 

package/contracts/test/TestValidatorManager.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {IInbox} from "../../interfaces/IInbox.sol";
+
+/**
+ * Intended for testing Inbox.sol, which requires its validator manager
+ * to be a contract.
+ */
+contract TestValidatorManager {
+    function process(
+        IInbox _inbox,
+        bytes32 _root,
+        uint256 _index,
+        bytes calldata _message,
+        bytes32[32] calldata _proof,
+        uint256 _leafIndex
+    ) external {
+        _inbox.process(_root, _index, _message, _proof, _leafIndex);
+    }
+}