@hyperlane-xyz/core 1.5.8 → 3.1.0-beta0

package/contracts/middleware/libs/InterchainQueryMessage.sol

@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.13;
+
+import {CallLib} from "./Call.sol";
+
+/**
+ * Format of message:
+ * [   0: 32] Sender address
+ * [  32: 64] Message type (left padded with zeroes)
+ * [  64:???] Encoded call array
+ */
+library InterchainQueryMessage {
+    uint256 private constant SENDER_OFFSET = 0;
+    uint256 private constant TYPE_OFFSET = 32;
+    uint256 private constant CALLS_OFFSET = 64;
+
+    enum MessageType {
+        QUERY,
+        RESPONSE
+    }
+
+    /**
+     * @notice Parses and returns the query sender from the provided message
+     * @param _message The interchain query message
+     * @return The query sender as bytes32
+     */
+    function sender(bytes calldata _message) internal pure returns (bytes32) {
+        return bytes32(_message[SENDER_OFFSET:TYPE_OFFSET]);
+    }
+
+    /**
+     * @notice Parses and returns the message type from the provided message
+     * @param _message The interchain query message
+     * @return The message type (query or response)
+     */
+    function messageType(bytes calldata _message)
+        internal
+        pure
+        returns (MessageType)
+    {
+        // left padded with zeroes
+        return MessageType(uint8(bytes1(_message[CALLS_OFFSET - 1])));
+    }
+
+    /**
+     * @notice Returns formatted InterchainQueryMessage, type == QUERY
+     * @param _sender The query sender as bytes32
+     * @param _calls The sequence of queries to make, with the corresponding
+     * response callbacks
+     * @return Formatted message body
+     */
+    function encode(
+        bytes32 _sender,
+        CallLib.StaticCallWithCallback[] calldata _calls
+    ) internal pure returns (bytes memory) {
+        return abi.encode(_sender, MessageType.QUERY, _calls);
+    }
+
+    /**
+     * @notice Returns formatted InterchainQueryMessage, type == QUERY
+     * @param _sender The query sender as bytes32
+     * @param _to The address of the contract to query
+     * @param _data The calldata encoding the query
+     * @param _callback The calldata of the callback that will be made on the sender.
+     * The return value of the query will be appended.
+     * @return Formatted message body
+     */
+    function encode(
+        bytes32 _sender,
+        address _to,
+        bytes memory _data,
+        bytes memory _callback
+    ) internal pure returns (bytes memory) {
+        CallLib.StaticCallWithCallback[]
+            memory _calls = new CallLib.StaticCallWithCallback[](1);
+        _calls[0] = CallLib.build(_to, _data, _callback);
+        return abi.encode(_sender, MessageType.QUERY, _calls);
+    }
+
+    /**
+     * @notice Parses and returns the calls and callbacks from the message
+     * @param _message The interchain query message, type == QUERY
+     * @return _calls The sequence of queries to make with the corresponding
+     * response callbacks
+     */
+    function callsWithCallbacks(bytes calldata _message)
+        internal
+        pure
+        returns (CallLib.StaticCallWithCallback[] memory _calls)
+    {
+        assert(messageType(_message) == MessageType.QUERY);
+        (, , _calls) = abi.decode(
+            _message,
+            (bytes32, MessageType, CallLib.StaticCallWithCallback[])
+        );
+    }
+
+    /**
+     * @notice Returns formatted InterchainQueryMessage, type == RESPONSE
+     * @param _sender The query sender as bytes32
+     * @param _calls The sequence of callbacks to make
+     * @return Formatted message body
+     */
+    function encode(bytes32 _sender, bytes[] memory _calls)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encode(_sender, MessageType.RESPONSE, _calls);
+    }
+
+    /**
+     * @notice Parses and returns the callbacks from the message
+     * @param _message The interchain query message, type == RESPONSE
+     * @return _calls The sequence of callbacks to make
+     */
+    function rawCalls(bytes calldata _message)
+        internal
+        pure
+        returns (bytes[] memory _calls)
+    {
+        assert(messageType(_message) == MessageType.RESPONSE);
+        (, , _calls) = abi.decode(_message, (bytes32, MessageType, bytes[]));
+    }
+}

package/contracts/middleware/libs/OwnableMulticall.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.13;
+
+// ============ Internal Imports ============
+import {CallLib} from "./Call.sol";
+
+/*
+ * @title OwnableMulticall
+ * @dev Permits immutable owner address to execute calls with value to other contracts.
+ */
+contract OwnableMulticall {
+    address public immutable owner;
+
+    constructor(address _owner) {
+        owner = _owner;
+    }
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "!owner");
+        _;
+    }
+
+    function multicall(CallLib.Call[] calldata calls) external onlyOwner {
+        return CallLib.multicall(calls);
+    }
+
+    // solhint-disable-next-line no-empty-blocks
+    receive() external payable {}
+}

package/contracts/middleware/liquidity-layer/LiquidityLayerRouter.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.13;
 
-import {Router} from "../../Router.sol";
+import {Router} from "../../client/Router.sol";
 
 import {ILiquidityLayerRouter} from "../../interfaces/ILiquidityLayerRouter.sol";
 import {ICircleMessageTransmitter} from "./interfaces/circle/ICircleMessageTransmitter.sol";
@@ -21,21 +21,20 @@ contract LiquidityLayerRouter is Router, ILiquidityLayerRouter {
 
     event LiquidityLayerAdapterSet(string indexed bridge, address adapter);
 
+    constructor(address _mailbox) Router(_mailbox) {}
+
     /**
      * @notice Initializes the Router contract with Hyperlane core contracts and the address of the interchain security module.
-     * @param _mailbox The address of the mailbox contract.
      * @param _interchainGasPaymaster The address of the interchain gas paymaster contract.
      * @param _interchainSecurityModule The address of the interchain security module contract.
      * @param _owner The address with owner privileges.
      */
     function initialize(
-        address _mailbox,
         address _interchainGasPaymaster,
         address _interchainSecurityModule,
         address _owner
     ) external initializer {
-        __HyperlaneConnectionClient_initialize(
-            _mailbox,
+        _MailboxClient_initialize(
             _interchainGasPaymaster,
             _interchainSecurityModule,
             _owner

package/contracts/middleware/liquidity-layer/adapters/CircleBridgeAdapter.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.13;
 
-import {Router} from "../../../Router.sol";
+import {Router} from "../../../client/Router.sol";
 
 import {ITokenMessenger} from "../interfaces/circle/ITokenMessenger.sol";
 import {ICircleMessageTransmitter} from "../interfaces/circle/ICircleMessageTransmitter.sol";
@@ -62,6 +62,8 @@ contract CircleBridgeAdapter is ILiquidityLayerAdapter, Router {
         _;
     }
 
+    constructor(address _mailbox) Router(_mailbox) {}
+
     /**
      * @param _owner The new owner.
      * @param _tokenMessenger The TokenMessenger contract.

package/contracts/middleware/liquidity-layer/adapters/PortalAdapter.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.13;
 
-import {Router} from "../../../Router.sol";
+import {Router} from "../../../client/Router.sol";
 
 import {IPortalTokenBridge} from "../interfaces/portal/IPortalTokenBridge.sol";
 import {ILiquidityLayerAdapter} from "../interfaces/ILiquidityLayerAdapter.sol";
@@ -21,14 +21,14 @@ contract PortalAdapter is ILiquidityLayerAdapter, Router {
     /// @notice transferId => token address
     mapping(bytes32 => address) public portalTransfersProcessed;
 
-    uint32 public localDomain;
-
     // We could technically use Portal's sequence number here but it doesn't
     // get passed through, so we would have to parse the VAA twice
     // 224 bits should be large enough and allows us to pack into a single slot
     // with a Hyperlane domain
     uint224 public nonce = 0;
 
+    constructor(address _mailbox) Router(_mailbox) {}
+
     /**
      * @notice Emits the nonce of the Portal message when a token is bridged.
      * @param nonce The nonce of the Portal message.
@@ -54,13 +54,11 @@ contract PortalAdapter is ILiquidityLayerAdapter, Router {
     }
 
     /**
-     * @param _localDomain The local hyperlane domain
      * @param _owner The new owner.
      * @param _portalTokenBridge The Portal TokenBridge contract.
      * @param _liquidityLayerRouter The LiquidityLayerRouter contract.
      */
     function initialize(
-        uint32 _localDomain,
         address _owner,
         address _portalTokenBridge,
         address _liquidityLayerRouter
@@ -68,7 +66,6 @@ contract PortalAdapter is ILiquidityLayerAdapter, Router {
         // Transfer ownership of the contract to deployer
         _transferOwnership(_owner);
 
-        localDomain = _localDomain;
         portalTokenBridge = IPortalTokenBridge(_portalTokenBridge);
         liquidityLayerRouter = _liquidityLayerRouter;
     }

package/contracts/mock/MockERC5164.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT or Apache-2.0
 pragma solidity ^0.8.13;
 
-import {IMessageDispatcher} from "../hooks/ERC5164/interfaces/IMessageDispatcher.sol";
+import {IMessageDispatcher} from "../interfaces/hooks/IMessageDispatcher.sol";
 
 contract MockMessageDispatcher is IMessageDispatcher {
     function dispatchMessage(

package/contracts/mock/MockHyperlaneEnvironment.sol

@@ -2,9 +2,8 @@
 pragma solidity ^0.8.13;
 
 import "./MockMailbox.sol";
-import "../middleware/InterchainQueryRouter.sol";
 import "../test/TestInterchainGasPaymaster.sol";
-import "../test/TestMultisigIsm.sol";
+import "../test/TestIsm.sol";
 
 import {TypeCasts} from "../libs/TypeCasts.sol";
 
@@ -15,7 +14,6 @@ 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;
@@ -27,46 +25,20 @@ 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 TestIsm();
+        isms[destinationDomain] = new TestIsm();
 
-        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]);
+        igps[originDomain] = new TestInterchainGasPaymaster();
+        igps[destinationDomain] = new TestInterchainGasPaymaster();
+
+        originMailbox.transferOwnership(msg.sender);
+        destinationMailbox.transferOwnership(msg.sender);
 
         mailboxes[_originDomain] = originMailbox;
         mailboxes[_destinationDomain] = destinationMailbox;
-
-        InterchainQueryRouter originQueryRouter = new InterchainQueryRouter();
-        InterchainQueryRouter destinationQueryRouter = new InterchainQueryRouter();
-
-        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
-        );
-
-        originQueryRouter.enrollRemoteRouter(
-            _destinationDomain,
-            TypeCasts.addressToBytes32(address(destinationQueryRouter))
-        );
-        destinationQueryRouter.enrollRemoteRouter(
-            _originDomain,
-            TypeCasts.addressToBytes32(address(originQueryRouter))
-        );
-
-        queryRouters[_originDomain] = originQueryRouter;
-        queryRouters[_destinationDomain] = destinationQueryRouter;
     }
 
     function processNextPendingMessage() public {

package/contracts/mock/MockMailbox.sol

@@ -3,39 +3,34 @@ 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";
 
-contract MockMailbox is Versioned {
-    using TypeCasts for address;
-    using TypeCasts for bytes32;
-    // Domain of chain on which the contract is deployed
+import {TestIsm} from "../test/TestIsm.sol";
+import {TestPostDispatchHook} from "../test/TestPostDispatchHook.sol";
 
-    // ============ Constants ============
-    uint32 public immutable localDomain;
-    uint256 public constant MAX_MESSAGE_BODY_BYTES = 2 * 2**10;
+contract MockMailbox is Mailbox {
+    using Message for bytes;
 
-    uint32 public outboundNonce = 0;
     uint32 public inboundUnprocessedNonce = 0;
     uint32 public inboundProcessedNonce = 0;
-    IInterchainSecurityModule public defaultIsm;
+
     mapping(uint32 => MockMailbox) public remoteMailboxes;
-    mapping(uint256 => MockMessage) public inboundMessages;
+    mapping(uint256 => bytes) public inboundMessages;
 
-    struct MockMessage {
-        uint32 nonce;
-        uint32 origin;
-        address sender;
-        address recipient;
-        bytes body;
-    }
+    constructor(uint32 _domain) Mailbox(_domain) {
+        TestIsm ism = new TestIsm();
+        defaultIsm = ism;
 
-    constructor(uint32 _domain) {
-        localDomain = _domain;
-    }
+        TestPostDispatchHook hook = new TestPostDispatchHook();
+        defaultHook = hook;
+        requiredHook = hook;
 
-    function setDefaultIsm(IInterchainSecurityModule _module) external {
-        defaultIsm = _module;
+        _transferOwnership(msg.sender);
+        _disableInitializers();
     }
 
     function addRemoteMailbox(uint32 _domain, MockMailbox _mailbox) external {
@@ -43,92 +38,43 @@ contract MockMailbox is Versioned {
     }
 
     function dispatch(
-        uint32 _destinationDomain,
-        bytes32 _recipientAddress,
-        bytes calldata _messageBody
-    ) external returns (bytes32) {
-        require(_messageBody.length <= MAX_MESSAGE_BODY_BYTES, "msg too long");
-        MockMailbox _destinationMailbox = remoteMailboxes[_destinationDomain];
+        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];
         require(
             address(_destinationMailbox) != address(0),
             "Missing remote mailbox"
         );
-        _destinationMailbox.addInboundMessage(
-            outboundNonce,
-            localDomain,
-            msg.sender,
-            _recipientAddress.bytes32ToAddress(),
-            _messageBody
-        );
-        outboundNonce++;
-        return bytes32(0);
+        _destinationMailbox.addInboundMessage(message);
+
+        return id;
     }
 
-    function addInboundMessage(
-        uint32 _nonce,
-        uint32 _origin,
-        address _sender,
-        address _recipient,
-        bytes calldata _body
-    ) external {
-        inboundMessages[inboundUnprocessedNonce] = MockMessage(
-            _nonce,
-            _origin,
-            _sender,
-            _recipient,
-            _body
-        );
+    function addInboundMessage(bytes calldata message) external {
+        inboundMessages[inboundUnprocessedNonce] = message;
         inboundUnprocessedNonce++;
     }
 
     function processNextInboundMessage() public {
-        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
-        );
+        bytes memory _message = inboundMessages[inboundProcessedNonce];
+        Mailbox(address(this)).process("", _message);
         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/ERC20Test.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract ERC20Test is ERC20 {
+    uint8 public immutable _decimals;
+
+    constructor(
+        string memory name,
+        string memory symbol,
+        uint256 totalSupply,
+        uint8 __decimals
+    ) ERC20(name, symbol) {
+        _decimals = __decimals;
+        _mint(msg.sender, totalSupply);
+    }
+
+    function decimals() public view override returns (uint8) {
+        return _decimals;
+    }
+}

package/contracts/test/ERC721Test.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
+
+contract ERC721Test is ERC721Enumerable {
+    constructor(
+        string memory name,
+        string memory symbol,
+        uint256 _mintAmount
+    ) ERC721(name, symbol) {
+        for (uint256 i = 0; i < _mintAmount; i++) {
+            _mint(msg.sender, i);
+        }
+    }
+
+    function _baseURI() internal pure override returns (string memory) {
+        return "TEST-BASE-URI";
+    }
+}

package/contracts/test/LightTestRecipient.sol

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

package/contracts/test/TestGasRouter.sol

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

package/contracts/test/TestInterchainGasPaymaster.sol

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

package/contracts/test/TestIsm.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.6.11;
+
+import {IInterchainSecurityModule} from "../interfaces/IInterchainSecurityModule.sol";
+
+contract TestIsm is IInterchainSecurityModule {
+    uint8 public moduleType = uint8(Types.NULL);
+
+    bool verifyResult = true;
+
+    function setVerify(bool _verify) public {
+        verifyResult = _verify;
+    }
+
+    function verify(bytes calldata, bytes calldata) public view returns (bool) {
+        return verifyResult;
+    }
+}