@hyperlane-xyz/core 1.5.7-beta1 → 1.5.8

package/contracts/mock/MockHyperlaneEnvironment.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.13;
 
 import "./MockMailbox.sol";
+import "../middleware/InterchainQueryRouter.sol";
 import "../test/TestInterchainGasPaymaster.sol";
 import "../test/TestMultisigIsm.sol";
 
@@ -14,6 +15,7 @@ contract MockHyperlaneEnvironment {
     mapping(uint32 => MockMailbox) public mailboxes;
     mapping(uint32 => TestInterchainGasPaymaster) public igps;
     mapping(uint32 => IInterchainSecurityModule) public isms;
+    mapping(uint32 => InterchainQueryRouter) public queryRouters;
 
     constructor(uint32 _originDomain, uint32 _destinationDomain) {
         originDomain = _originDomain;
@@ -25,24 +27,46 @@ contract MockHyperlaneEnvironment {
         originMailbox.addRemoteMailbox(_destinationDomain, destinationMailbox);
         destinationMailbox.addRemoteMailbox(_originDomain, originMailbox);
 
+        igps[originDomain] = new TestInterchainGasPaymaster(address(this));
+        igps[destinationDomain] = new TestInterchainGasPaymaster(address(this));
+
         isms[originDomain] = new TestMultisigIsm();
         isms[destinationDomain] = new TestMultisigIsm();
 
-        originMailbox.setDefaultIsm(address(isms[originDomain]));
-        destinationMailbox.setDefaultIsm(address(isms[destinationDomain]));
+        originMailbox.setDefaultIsm(isms[originDomain]);
+        destinationMailbox.setDefaultIsm(isms[destinationDomain]);
+
+        mailboxes[_originDomain] = originMailbox;
+        mailboxes[_destinationDomain] = destinationMailbox;
 
-        igps[originDomain] = new TestInterchainGasPaymaster();
-        igps[destinationDomain] = new TestInterchainGasPaymaster();
+        InterchainQueryRouter originQueryRouter = new InterchainQueryRouter();
+        InterchainQueryRouter destinationQueryRouter = new InterchainQueryRouter();
 
-        // TODO: update routers with IGP paymentss
-        // originMailbox.setDefaultHook(address(igps[originDomain]));
-        // destinationMailbox.setDefaultHook(address(igps[destinationDomain]));
+        address owner = address(this);
+        originQueryRouter.initialize(
+            address(originMailbox),
+            address(igps[originDomain]),
+            address(isms[originDomain]),
+            owner
+        );
+        destinationQueryRouter.initialize(
+            address(destinationMailbox),
+            address(igps[destinationDomain]),
+            address(isms[destinationDomain]),
+            owner
+        );
 
-        originMailbox.transferOwnership(msg.sender);
-        destinationMailbox.transferOwnership(msg.sender);
+        originQueryRouter.enrollRemoteRouter(
+            _destinationDomain,
+            TypeCasts.addressToBytes32(address(destinationQueryRouter))
+        );
+        destinationQueryRouter.enrollRemoteRouter(
+            _originDomain,
+            TypeCasts.addressToBytes32(address(originQueryRouter))
+        );
 
-        mailboxes[_originDomain] = originMailbox;
-        mailboxes[_destinationDomain] = destinationMailbox;
+        queryRouters[_originDomain] = originQueryRouter;
+        queryRouters[_destinationDomain] = destinationQueryRouter;
     }
 
     function processNextPendingMessage() public {

package/contracts/mock/MockMailbox.sol

@@ -3,34 +3,39 @@ pragma solidity ^0.8.0;
 
 import {Versioned} from "../upgrade/Versioned.sol";
 import {TypeCasts} from "../libs/TypeCasts.sol";
-import {Message} from "../libs/Message.sol";
 import {IMessageRecipient} from "../interfaces/IMessageRecipient.sol";
 import {IInterchainSecurityModule, ISpecifiesInterchainSecurityModule} from "../interfaces/IInterchainSecurityModule.sol";
-import {Mailbox} from "../Mailbox.sol";
-import {IPostDispatchHook} from "../interfaces/hooks/IPostDispatchHook.sol";
 
-import {TestIsm} from "../test/TestIsm.sol";
-import {TestPostDispatchHook} from "../test/TestPostDispatchHook.sol";
+contract MockMailbox is Versioned {
+    using TypeCasts for address;
+    using TypeCasts for bytes32;
+    // Domain of chain on which the contract is deployed
 
-contract MockMailbox is Mailbox {
-    using Message for bytes;
+    // ============ Constants ============
+    uint32 public immutable localDomain;
+    uint256 public constant MAX_MESSAGE_BODY_BYTES = 2 * 2**10;
 
+    uint32 public outboundNonce = 0;
     uint32 public inboundUnprocessedNonce = 0;
     uint32 public inboundProcessedNonce = 0;
-
+    IInterchainSecurityModule public defaultIsm;
     mapping(uint32 => MockMailbox) public remoteMailboxes;
-    mapping(uint256 => bytes) public inboundMessages;
+    mapping(uint256 => MockMessage) public inboundMessages;
 
-    constructor(uint32 _domain) Mailbox(_domain) {
-        TestIsm ism = new TestIsm();
-        defaultIsm = ism;
+    struct MockMessage {
+        uint32 nonce;
+        uint32 origin;
+        address sender;
+        address recipient;
+        bytes body;
+    }
 
-        TestPostDispatchHook hook = new TestPostDispatchHook();
-        defaultHook = hook;
-        requiredHook = hook;
+    constructor(uint32 _domain) {
+        localDomain = _domain;
+    }
 
-        _transferOwnership(msg.sender);
-        _disableInitializers();
+    function setDefaultIsm(IInterchainSecurityModule _module) external {
+        defaultIsm = _module;
     }
 
     function addRemoteMailbox(uint32 _domain, MockMailbox _mailbox) external {
@@ -38,43 +43,92 @@ contract MockMailbox is Mailbox {
     }
 
     function dispatch(
-        uint32 destinationDomain,
-        bytes32 recipientAddress,
-        bytes calldata messageBody,
-        bytes calldata metadata,
-        IPostDispatchHook hook
-    ) public payable override returns (bytes32) {
-        bytes memory message = _buildMessage(
-            destinationDomain,
-            recipientAddress,
-            messageBody
-        );
-        bytes32 id = super.dispatch(
-            destinationDomain,
-            recipientAddress,
-            messageBody,
-            metadata,
-            hook
-        );
-
-        MockMailbox _destinationMailbox = remoteMailboxes[destinationDomain];
+        uint32 _destinationDomain,
+        bytes32 _recipientAddress,
+        bytes calldata _messageBody
+    ) external returns (bytes32) {
+        require(_messageBody.length <= MAX_MESSAGE_BODY_BYTES, "msg too long");
+        MockMailbox _destinationMailbox = remoteMailboxes[_destinationDomain];
         require(
             address(_destinationMailbox) != address(0),
             "Missing remote mailbox"
         );
-        _destinationMailbox.addInboundMessage(message);
-
-        return id;
+        _destinationMailbox.addInboundMessage(
+            outboundNonce,
+            localDomain,
+            msg.sender,
+            _recipientAddress.bytes32ToAddress(),
+            _messageBody
+        );
+        outboundNonce++;
+        return bytes32(0);
     }
 
-    function addInboundMessage(bytes calldata message) external {
-        inboundMessages[inboundUnprocessedNonce] = message;
+    function addInboundMessage(
+        uint32 _nonce,
+        uint32 _origin,
+        address _sender,
+        address _recipient,
+        bytes calldata _body
+    ) external {
+        inboundMessages[inboundUnprocessedNonce] = MockMessage(
+            _nonce,
+            _origin,
+            _sender,
+            _recipient,
+            _body
+        );
         inboundUnprocessedNonce++;
     }
 
     function processNextInboundMessage() public {
-        bytes memory _message = inboundMessages[inboundProcessedNonce];
-        Mailbox(address(this)).process("", _message);
+        MockMessage memory _message = inboundMessages[inboundProcessedNonce];
+        address _recipient = _message.recipient;
+        IInterchainSecurityModule _ism = _recipientIsm(_recipient);
+        if (address(_ism) != address(0)) {
+            // Do not pass any metadata because we expect to
+            // be using TestIsms
+            require(_ism.verify("", _encode(_message)), "ISM verify failed");
+        }
+
+        IMessageRecipient(_message.recipient).handle(
+            _message.origin,
+            _message.sender.addressToBytes32(),
+            _message.body
+        );
         inboundProcessedNonce++;
     }
+
+    function _encode(MockMessage memory _message)
+        private
+        view
+        returns (bytes memory)
+    {
+        return
+            abi.encodePacked(
+                VERSION,
+                _message.nonce,
+                _message.origin,
+                TypeCasts.addressToBytes32(_message.sender),
+                localDomain,
+                TypeCasts.addressToBytes32(_message.recipient),
+                _message.body
+            );
+    }
+
+    function _recipientIsm(address _recipient)
+        private
+        view
+        returns (IInterchainSecurityModule)
+    {
+        try
+            ISpecifiesInterchainSecurityModule(_recipient)
+                .interchainSecurityModule()
+        returns (IInterchainSecurityModule _val) {
+            if (address(_val) != address(0)) {
+                return _val;
+            }
+        } catch {}
+        return defaultIsm;
+    }
 }

package/contracts/test/LightTestRecipient.sol

@@ -9,7 +9,7 @@ contract LightTestRecipient is TestRecipient {
         uint32 _origin,
         bytes32 _sender,
         bytes calldata _data
-    ) external payable override {
+    ) external override {
         // do nothing
     }
 }

package/contracts/test/TestGasRouter.sol

@@ -1,18 +1,28 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 pragma solidity >=0.6.11;
 
-import "../client/GasRouter.sol";
+import "./TestRouter.sol";
+import "../GasRouter.sol";
 
-contract TestGasRouter is GasRouter {
-    constructor(address _mailbox) GasRouter(_mailbox) {}
-
-    function dispatch(uint32 _destination, bytes memory _msg) external payable {
-        _dispatch(_destination, _msg);
+contract TestGasRouter is TestRouter, GasRouter {
+    function dispatchWithGas(
+        uint32 _destinationDomain,
+        bytes memory _messageBody,
+        uint256 _gasPayment,
+        address _gasPaymentRefundAddress
+    ) external payable {
+        _dispatchWithGas(
+            _destinationDomain,
+            _messageBody,
+            _gasPayment,
+            _gasPaymentRefundAddress
+        );
     }
 
-    function _handle(
-        uint32,
-        bytes32,
-        bytes calldata
-    ) internal pure override {}
+    function dispatchWithGas(
+        uint32 _destinationDomain,
+        bytes memory _messageBody
+    ) external payable {
+        _dispatchWithGas(_destinationDomain, _messageBody);
+    }
 }

package/contracts/test/TestHyperlaneConnectionClient.sol

@@ -0,0 +1,18 @@
+// 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 {
+    constructor() {
+        _transferOwnership(msg.sender);
+    }
+
+    function initialize(address _mailbox) external initializer {
+        __HyperlaneConnectionClient_initialize(_mailbox);
+    }
+
+    function localDomain() external view returns (uint32) {
+        return mailbox.localDomain();
+    }
+}

package/contracts/test/TestInterchainGasPaymaster.sol

@@ -2,13 +2,14 @@
 pragma solidity >=0.8.0;
 
 // ============ Internal Imports ============
-import {InterchainGasPaymaster} from "../hooks/igp/InterchainGasPaymaster.sol";
+import {InterchainGasPaymaster} from "../igps/InterchainGasPaymaster.sol";
 
 contract TestInterchainGasPaymaster is InterchainGasPaymaster {
     uint256 public constant gasPrice = 10;
 
-    constructor() {
-        initialize(msg.sender, msg.sender);
+    // Ensure the same constructor interface as the inherited InterchainGasPaymaster
+    constructor(address _beneficiary) {
+        initialize(msg.sender, _beneficiary);
     }
 
     function quoteGasPayment(uint32, uint256 gasAmount)

package/contracts/test/TestLegacyMultisigIsm.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+import {LegacyMultisigIsm} from "../isms/multisig/LegacyMultisigIsm.sol";
+import {LegacyCheckpointLib} from "../libs/LegacyCheckpointLib.sol";
+
+contract TestLegacyMultisigIsm is LegacyMultisigIsm {
+    function getDomainHash(uint32 _origin, bytes32 _originMailbox)
+        external
+        pure
+        returns (bytes32)
+    {
+        return LegacyCheckpointLib.domainHash(_origin, _originMailbox);
+    }
+}

package/contracts/test/TestMailbox.sol

@@ -3,15 +3,28 @@ pragma solidity >=0.8.0;
 
 import {Mailbox} from "../Mailbox.sol";
 import {TypeCasts} from "../libs/TypeCasts.sol";
-import {Message} from "../libs/Message.sol";
 import {MerkleLib} from "../libs/Merkle.sol";
 import {IMessageRecipient} from "../interfaces/IMessageRecipient.sol";
 
 contract TestMailbox is Mailbox {
     using TypeCasts for bytes32;
 
-    constructor(uint32 _localDomain) Mailbox(_localDomain) {
-        _transferOwnership(msg.sender);
+    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(
@@ -26,34 +39,4 @@ contract TestMailbox is Mailbox {
             _body
         );
     }
-
-    function buildOutboundMessage(
-        uint32 destinationDomain,
-        bytes32 recipientAddress,
-        bytes calldata body
-    ) external view returns (bytes memory) {
-        return _buildMessage(destinationDomain, recipientAddress, body);
-    }
-
-    function buildInboundMessage(
-        uint32 originDomain,
-        bytes32 recipientAddress,
-        bytes32 senderAddress,
-        bytes calldata body
-    ) external view returns (bytes memory) {
-        return
-            Message.formatMessage(
-                VERSION,
-                nonce,
-                originDomain,
-                senderAddress,
-                localDomain,
-                recipientAddress,
-                body
-            );
-    }
-
-    function updateLatestDispatchedId(bytes32 _id) external {
-        latestDispatchedId = _id;
-    }
 }

package/contracts/test/TestQuery.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.8.13;
 
 import {InterchainQueryRouter} from "../middleware/InterchainQueryRouter.sol";
 import {TypeCasts} from "../libs/TypeCasts.sol";
-import {CallLib} from "../middleware/libs/Call.sol";
+import {CallLib} from "../libs/Call.sol";
 
 import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
 

package/contracts/test/TestQuerySender.sol

@@ -1,11 +1,13 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 pragma solidity >=0.8.0;
 
-import {InterchainQueryRouter} from "../middleware/InterchainQueryRouter.sol";
-import {CallLib} from "../middleware/libs/Call.sol";
+import {IInterchainGasPaymaster} from "../interfaces/IInterchainGasPaymaster.sol";
+import {IInterchainQueryRouter} from "../interfaces/middleware/IInterchainQueryRouter.sol";
+import {CallLib} from "../libs/Call.sol";
 
 contract TestQuerySender {
-    InterchainQueryRouter queryRouter;
+    IInterchainQueryRouter queryRouter;
+    IInterchainGasPaymaster interchainGasPaymaster;
 
     address public lastAddressResult;
     uint256 public lastUint256Result;
@@ -15,8 +17,14 @@ contract TestQuerySender {
     event ReceivedUint256Result(uint256 result);
     event ReceivedBytes32Result(bytes32 result);
 
-    function initialize(address _queryRouterAddress) external {
-        queryRouter = InterchainQueryRouter(_queryRouterAddress);
+    function initialize(
+        address _queryRouterAddress,
+        address _interchainGasPaymaster
+    ) external {
+        queryRouter = IInterchainQueryRouter(_queryRouterAddress);
+        interchainGasPaymaster = IInterchainGasPaymaster(
+            _interchainGasPaymaster
+        );
     }
 
     function queryAddress(
@@ -84,13 +92,21 @@ contract TestQuerySender {
         address _target,
         bytes calldata _targetData,
         bytes4 _callbackSelector,
-        uint256 /*_gasAmount*/
+        uint256 _gasAmount
     ) internal {
-        queryRouter.query(
-            _destinationDomain,
+        CallLib.StaticCallWithCallback[]
+            memory calls = new CallLib.StaticCallWithCallback[](1);
+        calls[0] = CallLib.build(
             _target,
             _targetData,
             abi.encodePacked(_callbackSelector)
         );
+        bytes32 _messageId = queryRouter.query(_destinationDomain, calls);
+        interchainGasPaymaster.payForGas{value: msg.value}(
+            _messageId,
+            _destinationDomain,
+            _gasAmount,
+            msg.sender
+        );
     }
 }

package/contracts/test/TestRecipient.sol

@@ -21,7 +21,6 @@ contract TestRecipient is
     event ReceivedMessage(
         uint32 indexed origin,
         bytes32 indexed sender,
-        uint256 indexed value,
         string message
     );
 
@@ -31,8 +30,8 @@ contract TestRecipient is
         uint32 _origin,
         bytes32 _sender,
         bytes calldata _data
-    ) external payable virtual override {
-        emit ReceivedMessage(_origin, _sender, msg.value, string(_data));
+    ) external virtual override {
+        emit ReceivedMessage(_origin, _sender, string(_data));
         lastSender = _sender;
         lastData = _data;
     }

package/contracts/test/TestRouter.sol

@@ -1,18 +1,20 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 pragma solidity >=0.6.11;
 
-import "../client/Router.sol";
+import "../Router.sol";
 
 contract TestRouter is Router {
     event InitializeOverload();
 
-    constructor(address _mailbox) Router(_mailbox) {}
-
-    function initialize(address _hook, address _interchainSecurityModule)
-        public
+    function initialize(address _mailbox, address _interchainGasPaymaster)
+        external
         initializer
     {
-        _MailboxClient_initialize(_hook, _interchainSecurityModule, msg.sender);
+        __HyperlaneConnectionClient_initialize(
+            _mailbox,
+            _interchainGasPaymaster
+        );
+        emit InitializeOverload();
     }
 
     function _handle(
@@ -37,7 +39,23 @@ contract TestRouter is Router {
         return _mustHaveRemoteRouter(_domain);
     }
 
-    function dispatch(uint32 _destination, bytes memory _msg) external payable {
+    function dispatch(uint32 _destination, bytes memory _msg) external {
         _dispatch(_destination, _msg);
     }
+
+    function dispatchWithGas(
+        uint32 _destinationDomain,
+        bytes memory _messageBody,
+        uint256 _gasAmount,
+        uint256 _gasPayment,
+        address _gasPaymentRefundAddress
+    ) external payable {
+        _dispatchWithGas(
+            _destinationDomain,
+            _messageBody,
+            _gasAmount,
+            _gasPayment,
+            _gasPaymentRefundAddress
+        );
+    }
 }

package/contracts/test/TestSendReceiver.sol

@@ -7,8 +7,6 @@ import {IInterchainGasPaymaster} from "../interfaces/IInterchainGasPaymaster.sol
 import {IMessageRecipient} from "../interfaces/IMessageRecipient.sol";
 import {IMailbox} from "../interfaces/IMailbox.sol";
 
-import {StandardHookMetadata} from "../hooks/libs/StandardHookMetadata.sol";
-
 contract TestSendReceiver is IMessageRecipient {
     using TypeCasts for address;
 
@@ -18,27 +16,49 @@ contract TestSendReceiver is IMessageRecipient {
 
     function dispatchToSelf(
         IMailbox _mailbox,
+        IInterchainGasPaymaster _paymaster,
         uint32 _destinationDomain,
         bytes calldata _messageBody
     ) external payable {
-        bytes memory hookMetadata = StandardHookMetadata.formatMetadata(
-            HANDLE_GAS_AMOUNT,
-            msg.sender
-        );
-        // TODO: handle topping up?
-        _mailbox.dispatch{value: msg.value}(
+        bytes32 _messageId = _mailbox.dispatch(
             _destinationDomain,
             address(this).addressToBytes32(),
-            _messageBody,
-            hookMetadata
+            _messageBody
         );
+        uint256 _blockHashNum = uint256(previousBlockHash());
+        uint256 _value = msg.value;
+        if (_blockHashNum % 5 == 0) {
+            // Pay in two separate calls, resulting in 2 distinct events
+            uint256 _halfPayment = _value / 2;
+            uint256 _halfGasAmount = HANDLE_GAS_AMOUNT / 2;
+            _paymaster.payForGas{value: _halfPayment}(
+                _messageId,
+                _destinationDomain,
+                _halfGasAmount,
+                msg.sender
+            );
+            _paymaster.payForGas{value: _value - _halfPayment}(
+                _messageId,
+                _destinationDomain,
+                HANDLE_GAS_AMOUNT - _halfGasAmount,
+                msg.sender
+            );
+        } else {
+            // Pay the entire msg.value in one call
+            _paymaster.payForGas{value: _value}(
+                _messageId,
+                _destinationDomain,
+                HANDLE_GAS_AMOUNT,
+                msg.sender
+            );
+        }
     }
 
     function handle(
         uint32,
         bytes32,
         bytes calldata
-    ) external payable override {
+    ) external override {
         bytes32 blockHash = previousBlockHash();
         bool isBlockHashEndIn0 = uint256(blockHash) % 16 == 0;
         require(!isBlockHashEndIn0, "block hash ends in 0");

package/contracts/test/bad-recipient/BadRecipient1.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {IMessageRecipient} from "../../interfaces/IMessageRecipient.sol";
+
+contract BadRecipient1 is IMessageRecipient {
+    function handle(
+        uint32,
+        bytes32,
+        bytes calldata
+    ) external pure override {
+        assembly {
+            revert(0, 0)
+        }
+    }
+}

package/contracts/test/bad-recipient/BadRecipient2.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+contract BadRecipient2 {
+    function handle(uint32, bytes32) external pure {} // solhint-disable-line no-empty-blocks
+}

package/contracts/test/bad-recipient/BadRecipient3.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {IMessageRecipient} from "../../interfaces/IMessageRecipient.sol";
+
+contract BadRecipient3 is IMessageRecipient {
+    function handle(
+        uint32,
+        bytes32,
+        bytes calldata
+    ) external pure override {
+        assembly {
+            mstore(0, 0xabcdef)
+            revert(0, 32)
+        }
+    }
+}