@hyperlane-xyz/core 0.5.3 → 0.5.4-1

package/contracts/mock/MockInterchainAccountRouter.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.13;
+
+import {OwnableMulticall, Call} from "../OwnableMulticall.sol";
+import {IInterchainAccountRouter} from "../../interfaces/IInterchainAccountRouter.sol";
+
+// ============ External Imports ============
+import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+
+/*
+ * @title The Hello World App
+ * @dev You can use this simple app as a starting point for your own application.
+ */
+contract MockInterchainAccountRouter is IInterchainAccountRouter {
+    struct PendingCall {
+        uint32 originDomain;
+        address sender;
+        bytes serializedCalls;
+    }
+
+    uint32 public originDomain;
+
+    mapping(uint256 => PendingCall) pendingCalls;
+    uint256 totalCalls = 0;
+    uint256 callsProcessed = 0;
+
+    bytes constant bytecode = type(OwnableMulticall).creationCode;
+    bytes32 constant bytecodeHash = bytes32(keccak256(bytecode));
+
+    event InterchainAccountCreated(
+        uint32 indexed origin,
+        address sender,
+        address account
+    );
+
+    constructor(uint32 _originDomain) {
+        originDomain = _originDomain;
+    }
+
+    function dispatch(uint32, Call[] calldata calls)
+        external
+        returns (bytes32)
+    {
+        pendingCalls[totalCalls] = PendingCall(
+            originDomain,
+            msg.sender,
+            abi.encode(calls)
+        );
+        totalCalls += 1;
+        return keccak256(abi.encodePacked(totalCalls));
+    }
+
+    function getInterchainAccount(uint32 _origin, address _sender)
+        public
+        view
+        returns (address)
+    {
+        return _getInterchainAccount(_salt(_origin, _sender));
+    }
+
+    function getDeployedInterchainAccount(uint32 _origin, address _sender)
+        public
+        returns (OwnableMulticall)
+    {
+        bytes32 salt = _salt(_origin, _sender);
+        address interchainAccount = _getInterchainAccount(salt);
+        if (!Address.isContract(interchainAccount)) {
+            interchainAccount = Create2.deploy(0, salt, bytecode);
+            emit InterchainAccountCreated(_origin, _sender, interchainAccount);
+        }
+        return OwnableMulticall(interchainAccount);
+    }
+
+    function _salt(uint32 _origin, address _sender)
+        internal
+        pure
+        returns (bytes32)
+    {
+        return bytes32(abi.encodePacked(_origin, _sender));
+    }
+
+    function _getInterchainAccount(bytes32 salt)
+        internal
+        view
+        returns (address)
+    {
+        return Create2.computeAddress(salt, bytecodeHash);
+    }
+
+    function processNextPendingCall() public {
+        PendingCall memory pendingCall = pendingCalls[callsProcessed];
+        Call[] memory calls = abi.decode(pendingCall.serializedCalls, (Call[]));
+
+        getDeployedInterchainAccount(originDomain, pendingCall.sender)
+            .proxyCalls(calls);
+    }
+}

package/contracts/mock/MockMailbox.sol

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {TypeCasts} from "../libs/TypeCasts.sol";
+import {IMessageRecipient} from "../../interfaces/IMessageRecipient.sol";
+
+contract MockMailbox {
+    using TypeCasts for address;
+    using TypeCasts for bytes32;
+    // Domain of chain on which the contract is deployed
+    uint32 public immutable domain;
+    uint32 public immutable version = 0;
+
+    uint256 public outboundNonce = 0;
+    uint256 public inboundUnprocessedNonce = 0;
+    uint256 public inboundProcessedNonce = 0;
+    mapping(uint32 => MockMailbox) public remoteMailboxes;
+    mapping(uint256 => Message) public inboundMessages;
+
+    struct Message {
+        uint32 origin;
+        address sender;
+        address recipient;
+        bytes body;
+    }
+
+    constructor(uint32 _domain) {
+        domain = _domain;
+    }
+
+    function addRemoteMailbox(uint32 _domain, MockMailbox _mailbox) external {
+        remoteMailboxes[_domain] = _mailbox;
+    }
+
+    function dispatch(
+        uint32 _destinationDomain,
+        bytes32 _recipientAddress,
+        bytes calldata _messageBody
+    ) external returns (bytes32) {
+        MockMailbox _destinationMailbox = remoteMailboxes[_destinationDomain];
+        require(
+            address(_destinationMailbox) != address(0),
+            "Missing remote mailbox"
+        );
+        _destinationMailbox.addInboundMessage(
+            domain,
+            msg.sender,
+            _recipientAddress.bytes32ToAddress(),
+            _messageBody
+        );
+        outboundNonce++;
+        return bytes32(0);
+    }
+
+    function addInboundMessage(
+        uint32 _origin,
+        address _sender,
+        address _recipient,
+        bytes calldata _body
+    ) external {
+        inboundMessages[inboundUnprocessedNonce] = Message(
+            _origin,
+            _sender,
+            _recipient,
+            _body
+        );
+        inboundUnprocessedNonce++;
+    }
+
+    function processNextInboundMessage() public {
+        Message memory _message = inboundMessages[inboundProcessedNonce];
+        IMessageRecipient(_message.recipient).handle(
+            _message.origin,
+            _message.sender.addressToBytes32(),
+            _message.body
+        );
+        inboundProcessedNonce++;
+    }
+}

package/contracts/test/TestHyperlaneConnectionClient.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.6.11;
+import {HyperlaneConnectionClient} from "../HyperlaneConnectionClient.sol";
+import {IMailbox} from "../../interfaces/IMailbox.sol";
+
+contract TestHyperlaneConnectionClient is HyperlaneConnectionClient {
+    function initialize(address _abacusConnectionManager) external initializer {
+        __HyperlaneConnectionClient_initialize(_abacusConnectionManager);
+    }
+
+    function localDomain() external view returns (uint32) {
+        return mailbox.localDomain();
+    }
+}

package/contracts/test/TestIsm.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {IInterchainSecurityModule} from "../../interfaces/IInterchainSecurityModule.sol";
+
+contract TestIsm is IInterchainSecurityModule {
+    bool public accept;
+
+    function setAccept(bool _val) external {
+        accept = _val;
+    }
+
+    function verify(bytes calldata, bytes calldata)
+        external
+        view
+        returns (bool)
+    {
+        return accept;
+    }
+}

package/contracts/test/{TestTokenBridgeMessageRecipient.sol → TestLiquidityLayerMessageRecipient.sol}

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.13;
 
-import {ITokenBridgeMessageRecipient} from "../middleware/token-bridge/interfaces/ITokenBridgeMessageRecipient.sol";
+import {ILiquidityLayerMessageRecipient} from "../middleware/liquidity-layer/interfaces/ILiquidityLayerMessageRecipient.sol";
 
-contract TestTokenBridgeMessageRecipient is ITokenBridgeMessageRecipient {
+contract TestLiquidityLayerMessageRecipient is ILiquidityLayerMessageRecipient {
     event HandledWithTokens(
         uint32 origin,
         bytes32 sender,

package/contracts/test/TestMailbox.sol

@@ -1,12 +1,42 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 pragma solidity >=0.8.0;
 
-import "../Mailbox.sol";
+import {Mailbox} from "../Mailbox.sol";
+import {TypeCasts} from "../libs/TypeCasts.sol";
+import {MerkleLib} from "../libs/Merkle.sol";
+import {IMessageRecipient} from "../../interfaces/IMessageRecipient.sol";
 
 contract TestMailbox is Mailbox {
-    constructor(uint32 _localDomain) Mailbox(_localDomain) {}
+    using TypeCasts for bytes32;
 
-    function initialize(address _validatorManager) external initializer {
-        __Mailbox_initialize(_validatorManager);
+    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
+        );
     }
 }

package/contracts/test/TestMerkle.sol

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

package/contracts/test/TestMessage.sol

@@ -6,12 +6,28 @@ 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)
     {
-        (, , , , _body) = _message.destructure();
+        return _message.body();
     }
 
     function origin(bytes calldata _message)
@@ -19,7 +35,7 @@ contract TestMessage {
         pure
         returns (uint32 _origin)
     {
-        (_origin, , , , ) = _message.destructure();
+        return _message.origin();
     }
 
     function sender(bytes calldata _message)
@@ -27,7 +43,7 @@ contract TestMessage {
         pure
         returns (bytes32 _sender)
     {
-        (, _sender, , , ) = _message.destructure();
+        return _message.sender();
     }
 
     function destination(bytes calldata _message)
@@ -35,7 +51,7 @@ contract TestMessage {
         pure
         returns (uint32 _destination)
     {
-        (, , _destination, , ) = _message.destructure();
+        return _message.destination();
     }
 
     function recipient(bytes calldata _message)
@@ -43,7 +59,7 @@ contract TestMessage {
         pure
         returns (bytes32 _recipient)
     {
-        (, , , _recipient, ) = _message.destructure();
+        return _message.recipient();
     }
 
     function recipientAddress(bytes calldata _message)
@@ -51,14 +67,10 @@ contract TestMessage {
         pure
         returns (address _recipient)
     {
-        (, , , _recipient, ) = _message.destructureAddresses();
+        return _message.recipientAddress();
     }
 
-    function leaf(bytes calldata _message, uint256 _leafIndex)
-        external
-        pure
-        returns (bytes32)
-    {
-        return _message.leaf(_leafIndex);
+    function id(bytes calldata _message) external pure returns (bytes32) {
+        return _message.id();
     }
 }

package/contracts/test/TestMultisigIsm.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+import {MultisigIsm} from "../isms/MultisigIsm.sol";
+
+contract TestMultisigIsm is MultisigIsm {
+    function getDomainHash(uint32 _origin, bytes32 _originMailbox)
+        external
+        pure
+        returns (bytes32)
+    {
+        return _getDomainHash(_origin, _originMailbox);
+    }
+
+    function getCheckpointDigest(bytes calldata _metadata, uint32 _origin)
+        external
+        pure
+        returns (bytes32)
+    {
+        return _getCheckpointDigest(_metadata, _origin);
+    }
+}

package/contracts/test/TestQuerySender.sol

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {Call, IInterchainQueryRouter} from "../../interfaces/IInterchainQueryRouter.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+
+contract TestQuerySender is Initializable {
+    IInterchainQueryRouter queryRouter;
+
+    address public lastAddressResult;
+    uint256 public lastUint256Result;
+    bytes32 public lastBytes32Result;
+
+    event ReceivedAddressResult(address result);
+    event ReceivedUint256Result(uint256 result);
+    event ReceivedBytes32Result(bytes32 result);
+
+    function initialize(address _queryRouterAddress) public initializer {
+        queryRouter = IInterchainQueryRouter(_queryRouterAddress);
+    }
+
+    function queryAddress(
+        uint32 _destinationDomain,
+        address _target,
+        bytes calldata _targetData
+    ) public {
+        queryRouter.query(
+            _destinationDomain,
+            Call({to: _target, data: _targetData}),
+            abi.encodePacked(this.handleQueryAddressResult.selector)
+        );
+    }
+
+    function handleQueryAddressResult(address _result) public {
+        emit ReceivedAddressResult(_result);
+        lastAddressResult = _result;
+    }
+
+    function queryUint256(
+        uint32 _destinationDomain,
+        address _target,
+        bytes calldata _targetData
+    ) public {
+        queryRouter.query(
+            _destinationDomain,
+            Call({to: _target, data: _targetData}),
+            abi.encodePacked(this.handleQueryUint256Result.selector)
+        );
+    }
+
+    function handleQueryUint256Result(uint256 _result) public {
+        emit ReceivedUint256Result(_result);
+        lastUint256Result = _result;
+    }
+
+    function queryBytes32(
+        uint32 _destinationDomain,
+        address _target,
+        bytes calldata _targetData
+    ) public {
+        queryRouter.query(
+            _destinationDomain,
+            Call({to: _target, data: _targetData}),
+            abi.encodePacked(this.handleQueryBytes32Result.selector)
+        );
+    }
+
+    function handleQueryBytes32Result(bytes32 _result) public {
+        emit ReceivedBytes32Result(_result);
+        lastBytes32Result = _result;
+    }
+}

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

package/contracts/test/TestTokenRecipient.sol

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 pragma solidity >=0.8.0;
 
-import {ITokenBridgeMessageRecipient} from "../middleware/token-bridge/interfaces/ITokenBridgeMessageRecipient.sol";
+import {ILiquidityLayerMessageRecipient} from "../middleware/liquidity-layer/interfaces/ILiquidityLayerMessageRecipient.sol";
 
-contract TestTokenRecipient is ITokenBridgeMessageRecipient {
+contract TestTokenRecipient is ILiquidityLayerMessageRecipient {
     bytes32 public lastSender;
     bytes public lastData;
     address public lastToken;