@hyperlane-xyz/core 1.5.4-beta0 → 1.5.5-beta0

package/contracts/middleware/InterchainAccountRouter.sol

@@ -2,16 +2,13 @@
 pragma solidity ^0.8.13;
 
 // ============ Internal Imports ============
-import {OwnableMulticall} from "../OwnableMulticall.sol";
-import {HyperlaneConnectionClient} from "../HyperlaneConnectionClient.sol";
-import {IRouter} from "../interfaces/IRouter.sol";
-import {IInterchainAccountRouter} from "../interfaces/middleware/IInterchainAccountRouter.sol";
-import {InterchainAccountMessage} from "../libs/middleware/InterchainAccountMessage.sol";
+import {OwnableMulticall} from "./libs/OwnableMulticall.sol";
+import {InterchainAccountMessage} from "./libs/InterchainAccountMessage.sol";
+import {CallLib} from "./libs/Call.sol";
 import {MinimalProxy} from "../libs/MinimalProxy.sol";
-import {CallLib} from "../libs/Call.sol";
 import {TypeCasts} from "../libs/TypeCasts.sol";
 import {EnumerableMapExtended} from "../libs/EnumerableMapExtended.sol";
-import {Router} from "../Router.sol";
+import {Router} from "../client/Router.sol";
 
 // ============ External Imports ============
 import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
@@ -22,7 +19,7 @@ import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Ini
  * @title A contract that allows accounts on chain A to call contracts via a
  * proxy contract on chain B.
  */
-contract InterchainAccountRouter is Router, IInterchainAccountRouter {
+contract InterchainAccountRouter is Router {
     // ============ Libraries ============
 
     using TypeCasts for address;
@@ -30,7 +27,6 @@ contract InterchainAccountRouter is Router, IInterchainAccountRouter {
 
     // ============ Constants ============
 
-    uint32 internal immutable localDomain;
     address internal implementation;
     bytes32 internal bytecodeHash;
 
@@ -80,38 +76,26 @@ contract InterchainAccountRouter is Router, IInterchainAccountRouter {
 
     // ============ Constructor ============
 
-    /**
-     * @notice Constructor deploys a relay (OwnableMulticall.sol) contract that
-     * will be cloned for each interchain account.
-     * @param _localDomain The Hyperlane domain ID on which this contract is
-     * deployed.
-     */
-    constructor(uint32 _localDomain) {
-        localDomain = _localDomain;
-    }
+    constructor(address _mailbox) Router(_mailbox) {}
 
     // ============ Initializers ============
 
     /**
      * @notice Initializes the contract with HyperlaneConnectionClient contracts
-     * @param _mailbox The address of the mailbox contract
      * @param _interchainGasPaymaster Unused but required by HyperlaneConnectionClient
      * @param _interchainSecurityModule The address of the local ISM 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
         );
-        require(localDomain == mailbox.localDomain(), "domain mismatch");
 
         implementation = address(new OwnableMulticall(address(this)));
         // cannot be stored immutably because it is dynamically sized
@@ -218,7 +202,7 @@ contract InterchainAccountRouter is Router, IInterchainAccountRouter {
         uint32 _origin,
         bytes32 _sender,
         bytes calldata _message
-    ) external override onlyMailbox {
+    ) external payable override onlyMailbox {
         (
             bytes32 _owner,
             bytes32 _ism,
@@ -229,7 +213,7 @@ contract InterchainAccountRouter is Router, IInterchainAccountRouter {
             _origin,
             _owner,
             _sender,
-            TypeCasts.bytes32ToAddress(_ism)
+            _ism.bytes32ToAddress()
         );
         _interchainAccount.multicall(_calls);
     }
@@ -249,13 +233,11 @@ contract InterchainAccountRouter is Router, IInterchainAccountRouter {
         address _router,
         address _ism
     ) external view returns (OwnableMulticall) {
-        bytes32 _routerAsBytes32 = TypeCasts.addressToBytes32(_router);
-        bytes32 _ownerAsBytes32 = TypeCasts.addressToBytes32(_owner);
         return
             getLocalInterchainAccount(
                 _origin,
-                _ownerAsBytes32,
-                _routerAsBytes32,
+                _owner.addressToBytes32(),
+                _router.addressToBytes32(),
                 _ism
             );
     }
@@ -274,8 +256,8 @@ contract InterchainAccountRouter is Router, IInterchainAccountRouter {
         view
         returns (address)
     {
-        address _router = TypeCasts.bytes32ToAddress(routers(_destination));
-        address _ism = TypeCasts.bytes32ToAddress(isms[_destination]);
+        address _router = routers(_destination).bytes32ToAddress();
+        address _ism = isms[_destination].bytes32ToAddress();
         return getRemoteInterchainAccount(_owner, _router, _ism);
     }
 
@@ -298,8 +280,8 @@ contract InterchainAccountRouter is Router, IInterchainAccountRouter {
         return
             getDeployedInterchainAccount(
                 _origin,
-                TypeCasts.addressToBytes32(_owner),
-                TypeCasts.addressToBytes32(_router),
+                _owner.addressToBytes32(),
+                _router.addressToBytes32(),
                 _ism
             );
     }
@@ -322,7 +304,7 @@ contract InterchainAccountRouter is Router, IInterchainAccountRouter {
             _origin,
             _owner,
             _router,
-            TypeCasts.addressToBytes32(_ism)
+            _ism.addressToBytes32()
         );
         address payable _account = _getLocalInterchainAccount(_salt);
         if (!Address.isContract(_account)) {
@@ -351,12 +333,7 @@ contract InterchainAccountRouter is Router, IInterchainAccountRouter {
         return
             OwnableMulticall(
                 _getLocalInterchainAccount(
-                    _getSalt(
-                        _origin,
-                        _owner,
-                        _router,
-                        TypeCasts.addressToBytes32(_ism)
-                    )
+                    _getSalt(_origin, _owner, _router, _ism.addressToBytes32())
                 )
             );
     }
@@ -397,9 +374,9 @@ contract InterchainAccountRouter is Router, IInterchainAccountRouter {
         bytes32 _bytecodeHash = keccak256(_proxyBytecode);
         bytes32 _salt = _getSalt(
             localDomain,
-            TypeCasts.addressToBytes32(_owner),
-            TypeCasts.addressToBytes32(address(this)),
-            TypeCasts.addressToBytes32(_ism)
+            _owner.addressToBytes32(),
+            address(this).addressToBytes32(),
+            _ism.addressToBytes32()
         );
         return Create2.computeAddress(_salt, _bytecodeHash, _router);
     }

package/contracts/middleware/InterchainQueryRouter.sol

@@ -2,10 +2,9 @@
 pragma solidity ^0.8.13;
 
 // ============ Internal Imports ============
-import {CallLib} from "../libs/Call.sol";
-import {Router} from "../Router.sol";
-import {IInterchainQueryRouter} from "../interfaces/middleware/IInterchainQueryRouter.sol";
-import {InterchainQueryMessage} from "../libs/middleware/InterchainQueryMessage.sol";
+import {Router} from "../client/Router.sol";
+import {CallLib} from "./libs/Call.sol";
+import {InterchainQueryMessage} from "./libs/InterchainQueryMessage.sol";
 import {TypeCasts} from "../libs/TypeCasts.sol";
 
 // ============ External Imports ============
@@ -17,9 +16,10 @@ import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Ini
  * @title Interchain Query Router that performs remote view calls on other chains and returns the result.
  * @dev Currently does not support Sovereign Consensus (user specified Interchain Security Modules).
  */
-contract InterchainQueryRouter is Router, IInterchainQueryRouter {
+contract InterchainQueryRouter is Router {
     using TypeCasts for address;
     using TypeCasts for bytes32;
+    using InterchainQueryMessage for bytes;
 
     /**
      * @notice Emitted when a query is dispatched to another chain.
@@ -40,21 +40,20 @@ contract InterchainQueryRouter is Router, IInterchainQueryRouter {
      */
     event QueryResolved(uint32 indexed destination, address indexed sender);
 
+    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
@@ -117,9 +116,8 @@ contract InterchainQueryRouter is Router, IInterchainQueryRouter {
         bytes32, // router sender
         bytes calldata _message
     ) internal override {
-        InterchainQueryMessage.MessageType messageType = InterchainQueryMessage
-            .messageType(_message);
-        bytes32 sender = InterchainQueryMessage.sender(_message);
+        InterchainQueryMessage.MessageType messageType = _message.messageType();
+        bytes32 sender = _message.sender();
         if (messageType == InterchainQueryMessage.MessageType.QUERY) {
             CallLib.StaticCallWithCallback[]
                 memory callsWithCallback = InterchainQueryMessage
@@ -134,7 +132,7 @@ contract InterchainQueryRouter is Router, IInterchainQueryRouter {
             );
         } else if (messageType == InterchainQueryMessage.MessageType.RESPONSE) {
             address senderAddress = sender.bytes32ToAddress();
-            bytes[] memory rawCalls = InterchainQueryMessage.rawCalls(_message);
+            bytes[] memory rawCalls = _message.rawCalls();
             CallLib.multicallto(senderAddress, rawCalls);
             emit QueryResolved(_origin, senderAddress);
         } else {

package/contracts/middleware/libs/Call.sol

@@ -0,0 +1,145 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.13;
+
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+
+import {TypeCasts} from "../../libs/TypeCasts.sol";
+
+library CallLib {
+    struct StaticCall {
+        // supporting non EVM targets
+        bytes32 to;
+        bytes data;
+    }
+
+    struct Call {
+        // supporting non EVM targets
+        bytes32 to;
+        uint256 value;
+        bytes data;
+    }
+
+    struct StaticCallWithCallback {
+        StaticCall _call;
+        bytes callback;
+    }
+
+    function call(Call memory _call)
+        internal
+        returns (bytes memory returnData)
+    {
+        return
+            Address.functionCallWithValue(
+                TypeCasts.bytes32ToAddress(_call.to),
+                _call.data,
+                _call.value
+            );
+    }
+
+    function staticcall(StaticCall memory _call)
+        private
+        view
+        returns (bytes memory)
+    {
+        return
+            Address.functionStaticCall(
+                TypeCasts.bytes32ToAddress(_call.to),
+                _call.data
+            );
+    }
+
+    function staticcall(StaticCallWithCallback memory _call)
+        internal
+        view
+        returns (bytes memory callback)
+    {
+        return bytes.concat(_call.callback, staticcall(_call._call));
+    }
+
+    function multicall(Call[] memory calls) internal {
+        uint256 i = 0;
+        uint256 len = calls.length;
+        while (i < len) {
+            call(calls[i]);
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function multistaticcall(StaticCallWithCallback[] memory _calls)
+        internal
+        view
+        returns (bytes[] memory)
+    {
+        uint256 i = 0;
+        uint256 len = _calls.length;
+        bytes[] memory callbacks = new bytes[](len);
+        while (i < len) {
+            callbacks[i] = staticcall(_calls[i]);
+            unchecked {
+                ++i;
+            }
+        }
+        return callbacks;
+    }
+
+    function multicallto(address to, bytes[] memory calls) internal {
+        uint256 i = 0;
+        uint256 len = calls.length;
+        while (i < len) {
+            Address.functionCall(to, calls[i]);
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function build(bytes32 to, bytes memory data)
+        internal
+        pure
+        returns (StaticCall memory)
+    {
+        return StaticCall(to, data);
+    }
+
+    function build(address to, bytes memory data)
+        internal
+        pure
+        returns (StaticCall memory)
+    {
+        return build(TypeCasts.addressToBytes32(to), data);
+    }
+
+    function build(
+        bytes32 to,
+        uint256 value,
+        bytes memory data
+    ) internal pure returns (Call memory) {
+        return Call(to, value, data);
+    }
+
+    function build(
+        address to,
+        uint256 value,
+        bytes memory data
+    ) internal pure returns (Call memory) {
+        return Call(TypeCasts.addressToBytes32(to), value, data);
+    }
+
+    function build(
+        bytes32 to,
+        bytes memory data,
+        bytes memory callback
+    ) internal pure returns (StaticCallWithCallback memory) {
+        return StaticCallWithCallback(build(to, data), callback);
+    }
+
+    function build(
+        address to,
+        bytes memory data,
+        bytes memory callback
+    ) internal pure returns (StaticCallWithCallback memory) {
+        return StaticCallWithCallback(build(to, data), callback);
+    }
+}

package/contracts/middleware/libs/InterchainAccountMessage.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {CallLib} from "./Call.sol";
+import {TypeCasts} from "../../libs/TypeCasts.sol";
+
+/**
+ * Format of message:
+ * [   0:  32] ICA owner
+ * [  32:  64] ICA ISM
+ * [  64:????] Calls, abi encoded
+ */
+library InterchainAccountMessage {
+    using TypeCasts for bytes32;
+
+    /**
+     * @notice Returns formatted (packed) InterchainAccountMessage
+     * @dev This function should only be used in memory message construction.
+     * @param _owner The owner of the interchain account
+     * @param _ism The address of the remote ISM
+     * @param _to The address of the contract to call
+     * @param _value The value to include in the call
+     * @param _data The calldata
+     * @return Formatted message body
+     */
+    function encode(
+        address _owner,
+        bytes32 _ism,
+        address _to,
+        uint256 _value,
+        bytes memory _data
+    ) internal pure returns (bytes memory) {
+        CallLib.Call[] memory _calls = new CallLib.Call[](1);
+        _calls[0] = CallLib.build(_to, _value, _data);
+        return abi.encode(TypeCasts.addressToBytes32(_owner), _ism, _calls);
+    }
+
+    /**
+     * @notice Returns formatted (packed) InterchainAccountMessage
+     * @dev This function should only be used in memory message construction.
+     * @param _owner The owner of the interchain account
+     * @param _ism The address of the remote ISM
+     * @param _calls The sequence of calls to make
+     * @return Formatted message body
+     */
+    function encode(
+        bytes32 _owner,
+        bytes32 _ism,
+        CallLib.Call[] calldata _calls
+    ) internal pure returns (bytes memory) {
+        return abi.encode(_owner, _ism, _calls);
+    }
+
+    /**
+     * @notice Returns formatted (packed) InterchainAccountMessage
+     * @dev This function should only be used in memory message construction.
+     * @param _owner The owner of the interchain account
+     * @param _ism The address of the remote ISM
+     * @param _calls The sequence of calls to make
+     * @return Formatted message body
+     */
+    function encode(
+        address _owner,
+        bytes32 _ism,
+        CallLib.Call[] calldata _calls
+    ) internal pure returns (bytes memory) {
+        return encode(TypeCasts.addressToBytes32(_owner), _ism, _calls);
+    }
+
+    /**
+     * @notice Parses and returns the calls from the provided message
+     * @param _message The interchain account message
+     * @return The array of calls
+     */
+    function decode(bytes calldata _message)
+        internal
+        pure
+        returns (
+            bytes32,
+            bytes32,
+            CallLib.Call[] memory
+        )
+    {
+        return abi.decode(_message, (bytes32, bytes32, CallLib.Call[]));
+    }
+
+    /**
+     * @notice Parses and returns the ISM address from the provided message
+     * @param _message The interchain account message
+     * @return The ISM encoded in the message
+     */
+    function ism(bytes calldata _message) internal pure returns (address) {
+        return address(bytes20(_message[44:64]));
+    }
+}

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.