@hyperlane-xyz/core 1.5.8 → 3.0.0-beta0

package/contracts/libs/StaticAddressSetFactory.sol

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+// ============ External Imports ============
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
+
+// ============ Internal Imports ============
+import {MetaProxy} from "./MetaProxy.sol";
+
+abstract contract StaticThresholdAddressSetFactory {
+    // ============ Immutables ============
+    address public immutable implementation;
+
+    // ============ Constructor ============
+
+    constructor() {
+        implementation = _deployImplementation();
+    }
+
+    function _deployImplementation() internal virtual returns (address);
+
+    /**
+     * @notice Deploys a StaticThresholdAddressSet contract address for the given
+     * values
+     * @dev Consider sorting addresses to ensure contract reuse
+     * @param _values An array of addresses
+     * @param _threshold The threshold value to use
+     * @return set The contract address representing this StaticThresholdAddressSet
+     */
+    function deploy(address[] calldata _values, uint8 _threshold)
+        public
+        returns (address)
+    {
+        (bytes32 _salt, bytes memory _bytecode) = _saltAndBytecode(
+            _values,
+            _threshold
+        );
+        address _set = _getAddress(_salt, _bytecode);
+        if (!Address.isContract(_set)) {
+            _set = Create2.deploy(0, _salt, _bytecode);
+        }
+        return _set;
+    }
+
+    /**
+     * @notice Returns the StaticThresholdAddressSet contract address for the given
+     * values
+     * @dev Consider sorting addresses to ensure contract reuse
+     * @param _values An array of addresses
+     * @param _threshold The threshold value to use
+     * @return set The contract address representing this StaticThresholdAddressSet
+     */
+    function getAddress(address[] calldata _values, uint8 _threshold)
+        external
+        view
+        returns (address)
+    {
+        (bytes32 _salt, bytes memory _bytecode) = _saltAndBytecode(
+            _values,
+            _threshold
+        );
+        return _getAddress(_salt, _bytecode);
+    }
+
+    /**
+     * @notice Returns the StaticThresholdAddressSet contract address for the given
+     * values
+     * @param _salt The salt used in Create2
+     * @param _bytecode The metaproxy bytecode used in Create2
+     * @return set The contract address representing this StaticThresholdAddressSet
+     */
+    function _getAddress(bytes32 _salt, bytes memory _bytecode)
+        internal
+        view
+        returns (address)
+    {
+        bytes32 _bytecodeHash = keccak256(_bytecode);
+        return Create2.computeAddress(_salt, _bytecodeHash);
+    }
+
+    /**
+     * @notice Returns the create2 salt and bytecode for the given values
+     * @param _values An array of addresses
+     * @param _threshold The threshold value to use
+     * @return _salt The salt used in Create2
+     * @return _bytecode The metaproxy bytecode used in Create2
+     */
+    function _saltAndBytecode(address[] calldata _values, uint8 _threshold)
+        internal
+        view
+        returns (bytes32, bytes memory)
+    {
+        bytes memory _metadata = abi.encode(_values, _threshold);
+        bytes memory _bytecode = MetaProxy.bytecode(implementation, _metadata);
+        bytes32 _salt = keccak256(_metadata);
+        return (_salt, _bytecode);
+    }
+}
+
+abstract contract StaticAddressSetFactory is StaticThresholdAddressSetFactory {
+    /**
+     * @notice Deploys a StaticAddressSet contract address for the given
+     * values
+     * @dev Consider sorting addresses to ensure contract reuse
+     * @param _values An array of addresses
+     * @return set The contract address representing this StaticAddressSet
+     */
+    function deploy(address[] calldata _values) external returns (address) {
+        return super.deploy(_values, uint8(_values.length));
+    }
+
+    /**
+     * @notice Returns the StaticAddressSet contract address for the given
+     * values
+     * @dev Consider sorting addresses to ensure contract reuse
+     * @param _values An array of addresses
+     * @return set The contract address representing this StaticAddressSet
+     */
+    function getAddress(address[] calldata _values)
+        external
+        view
+        returns (address)
+    {
+        (bytes32 _salt, bytes memory _bytecode) = _saltAndBytecode(
+            _values,
+            uint8(_values.length)
+        );
+        return super._getAddress(_salt, _bytecode);
+    }
+}

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]));
+    }
+}