@hyperlane-xyz/core 1.1.3 → 1.1.4

package/contracts/GasRouter.sol

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.6.11;
+
+import {Router} from "./Router.sol";
+
+abstract contract GasRouter is Router {
+    // ============ Mutable Storage ============
+    mapping(uint32 => uint256) public destinationGas;
+
+    // ============ Events ============
+
+    /**
+     * @notice Emitted when a domain's destination gas is set.
+     * @param domain The domain of the router.
+     * @param gas The gas amount used by the handle function of the domain's router.
+     */
+    event DestinationGasSet(uint32 indexed domain, uint256 gas);
+
+    struct GasRouterConfig {
+        uint32 domain;
+        uint256 gas;
+    }
+
+    /**
+     * @notice Sets the gas amount dispatched for each configured domain.
+     * @param gasConfigs The array of GasRouterConfig structs
+     */
+    function setDestinationGas(GasRouterConfig[] calldata gasConfigs)
+        external
+        onlyOwner
+    {
+        for (uint256 i = 0; i < gasConfigs.length; i += 1) {
+            _setDestinationGas(gasConfigs[i].domain, gasConfigs[i].gas);
+        }
+    }
+
+    /**
+     * @notice Returns the gas payment required to dispatch a message to the given domain's router.
+     * @param _destinationDomain The domain of the router.
+     * @return _gasPayment Payment computed by the registered InterchainGasPaymaster.
+     */
+    function quoteGasPayment(uint32 _destinationDomain)
+        external
+        view
+        returns (uint256 _gasPayment)
+    {
+        return
+            interchainGasPaymaster.quoteGasPayment(
+                _destinationDomain,
+                destinationGas[_destinationDomain]
+            );
+    }
+
+    function _setDestinationGas(uint32 domain, uint256 gas) internal {
+        destinationGas[domain] = gas;
+        emit DestinationGasSet(domain, gas);
+    }
+
+    /**
+     * @dev Uses the destinationGas mapping to populate the gas amount for the message.
+     * @notice Dispatches a message to an enrolled router via the local router's Mailbox
+     * and pays for it to be relayed to the destination.
+     * @dev Reverts if there is no enrolled router for _destinationDomain.
+     * @param _destinationDomain The domain of the chain to which to send the message.
+     * @param _messageBody Raw bytes content of message.
+     * @param _gasPayment The amount of native tokens to pay for the message to be relayed.
+     * @param _gasPaymentRefundAddress The address to refund any gas overpayment to.
+     */
+    function _dispatchWithGas(
+        uint32 _destinationDomain,
+        bytes memory _messageBody,
+        uint256 _gasPayment,
+        address _gasPaymentRefundAddress
+    ) internal returns (bytes32 _messageId) {
+        return
+            _dispatchWithGas(
+                _destinationDomain,
+                _messageBody,
+                destinationGas[_destinationDomain],
+                _gasPayment,
+                _gasPaymentRefundAddress
+            );
+    }
+
+    /**
+     * @dev Passes `msg.value` as gas payment and `msg.sender` as gas payment refund address.
+     * @dev Uses the destinationGas mapping to populate the gas amount for the message.
+     * @param _destinationDomain The domain of the chain to send the message.
+     * @param _messageBody Raw bytes content of message.
+     */
+    function _dispatchWithGas(
+        uint32 _destinationDomain,
+        bytes memory _messageBody
+    ) internal returns (bytes32 _messageId) {
+        return
+            _dispatchWithGas(
+                _destinationDomain,
+                _messageBody,
+                msg.value,
+                msg.sender
+            );
+    }
+}

package/contracts/OwnableMulticall.sol

@@ -9,11 +9,9 @@ import {CallLib} from "./libs/Call.sol";
 
 /*
  * @title OwnableMulticall
- * @dev Allows only only address to execute calls to other contracts
+ * @dev Permits owner address to execute state mutating calls with value to other contracts
  */
 contract OwnableMulticall is OwnableUpgradeable {
-    using CallLib for CallLib.Call[];
-
     constructor() {
         _transferOwnership(msg.sender);
     }
@@ -23,6 +21,9 @@ contract OwnableMulticall is OwnableUpgradeable {
     }
 
     function proxyCalls(CallLib.Call[] calldata calls) external onlyOwner {
-        calls._multicall();
+        return CallLib.multicall(calls);
     }
+
+    // solhint-disable-next-line no-empty-blocks
+    receive() external payable {}
 }

package/contracts/PausableReentrancyGuard.sol

@@ -5,9 +5,9 @@ import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
 // adapted from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
 abstract contract PausableReentrancyGuardUpgradeable is Initializable {
+    uint256 private constant _ENTERED = 0;
     uint256 private constant _NOT_ENTERED = 1;
-    uint256 private constant _ENTERED = 2;
-    uint256 private constant _PAUSED = 3;
+    uint256 private constant _PAUSED = 2;
 
     uint256 private _status;
 

package/contracts/igps/InterchainGasPaymaster.sol

@@ -79,7 +79,8 @@ contract InterchainGasPaymaster is IInterchainGasPaymaster, OwnableUpgradeable {
      */
     function quoteGasPayment(uint32 _destinationDomain, uint256 _gasAmount)
         public
-        pure
+        view
+        virtual
         override
         returns (uint256)
     {

package/contracts/libs/Call.sol

@@ -3,52 +3,141 @@ pragma solidity ^0.8.13;
 
 import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 
+import {TypeCasts} from "./TypeCasts.sol";
+
 library CallLib {
-    struct Call {
-        address to;
+    struct StaticCall {
+        // supporting non EVM targets
+        bytes32 to;
         bytes data;
     }
 
-    function _multicall(address to, bytes[] memory calls) internal {
+    struct Call {
+        uint256 value;
+        StaticCall _call;
+    }
+
+    struct StaticCallWithCallback {
+        StaticCall _call;
+        bytes callback;
+    }
+
+    function target(StaticCall memory _call) internal pure returns (address) {
+        return TypeCasts.bytes32ToAddress(_call.to);
+    }
+
+    function call(Call memory _call)
+        internal
+        returns (bytes memory returnData)
+    {
+        return
+            Address.functionCallWithValue(
+                target(_call._call),
+                _call._call.data,
+                _call.value
+            );
+    }
+
+    function staticcall(StaticCall memory _call)
+        private
+        view
+        returns (bytes memory)
+    {
+        return Address.functionStaticCall(target(_call), _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) {
-            Address.functionCall(to, calls[i]);
+            call(calls[i]);
             unchecked {
                 ++i;
             }
         }
     }
 
-    function _multicall(Call[] memory calls) internal {
+    function multistaticcall(StaticCallWithCallback[] memory _calls)
+        internal
+        view
+        returns (bytes[] memory)
+    {
         uint256 i = 0;
-        uint256 len = calls.length;
+        uint256 len = _calls.length;
+        bytes[] memory callbacks = new bytes[](len);
         while (i < len) {
-            Address.functionCall(calls[i].to, calls[i].data);
+            callbacks[i] = staticcall(_calls[i]);
             unchecked {
                 ++i;
             }
         }
+        return callbacks;
     }
 
-    function _multicallAndResolve(Call[] memory calls, bytes[] memory callbacks)
-        internal
-        returns (bytes[] memory resolveCalls)
-    {
-        // reuse memory
-        resolveCalls = callbacks;
-
+    function multicallto(address to, bytes[] memory calls) internal {
         uint256 i = 0;
         uint256 len = calls.length;
         while (i < len) {
-            bytes memory returnData = Address.functionCall(
-                calls[i].to,
-                calls[i].data
-            );
-            resolveCalls[i] = bytes.concat(callbacks[i], returnData);
+            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(value, build(to, data));
+    }
+
+    function build(
+        address to,
+        uint256 value,
+        bytes memory data
+    ) internal pure returns (Call memory) {
+        return Call(value, build(to, 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/InterchainAccountRouter.sol

@@ -5,8 +5,10 @@ pragma solidity ^0.8.13;
 import {OwnableMulticall} from "../OwnableMulticall.sol";
 import {Router} from "../Router.sol";
 import {IInterchainAccountRouter} from "../../interfaces/IInterchainAccountRouter.sol";
+import {InterchainCallMessage} from "./InterchainCallMessage.sol";
 import {MinimalProxy} from "../libs/MinimalProxy.sol";
 import {CallLib} from "../libs/Call.sol";
+import {TypeCasts} from "../libs/TypeCasts.sol";
 
 // ============ External Imports ============
 import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
@@ -18,8 +20,11 @@ import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Ini
  * @dev Currently does not support Sovereign Consensus (user specified Interchain Security Modules).
  */
 contract InterchainAccountRouter is Router, IInterchainAccountRouter {
-    address immutable implementation;
-    bytes32 immutable bytecodeHash;
+    using TypeCasts for address;
+    using TypeCasts for bytes32;
+
+    address internal immutable implementation;
+    bytes32 internal immutable bytecodeHash;
 
     /**
      * @notice Emitted when an interchain account is created (first time message is sent from a given `origin`/`sender` pair)
@@ -29,7 +34,7 @@ contract InterchainAccountRouter is Router, IInterchainAccountRouter {
      */
     event InterchainAccountCreated(
         uint32 indexed origin,
-        address sender,
+        bytes32 sender,
         address account
     );
 
@@ -68,29 +73,20 @@ contract InterchainAccountRouter is Router, IInterchainAccountRouter {
      * @notice Dispatches a sequence of calls to be relayed by the sender's interchain account on the destination domain.
      * @param _destinationDomain The domain of the chain where the message will be sent to.
      * @param calls The sequence of calls to be relayed.
+     * @dev Recommend using CallLib.build to format the interchain calls.
      */
     function dispatch(uint32 _destinationDomain, CallLib.Call[] calldata calls)
         external
         returns (bytes32)
     {
-        return _dispatch(_destinationDomain, abi.encode(msg.sender, calls));
-    }
-
-    /**
-     * @notice Dispatches a single call to be relayed by the sender's interchain account on the destination domain.
-     * @param _destinationDomain The domain of the chain where the message will be sent to.
-     * @param target The address of the contract to be called.
-     * @param data The ABI-encoded data to be called on target contract.
-     * @return The message ID of the dispatched message.
-     */
-    function dispatch(
-        uint32 _destinationDomain,
-        address target,
-        bytes calldata data
-    ) external returns (bytes32) {
-        CallLib.Call[] memory calls = new CallLib.Call[](1);
-        calls[0] = CallLib.Call({to: target, data: data});
-        return _dispatch(_destinationDomain, abi.encode(msg.sender, calls));
+        return
+            _dispatch(
+                _destinationDomain,
+                InterchainCallMessage.format(
+                    calls,
+                    msg.sender.addressToBytes32()
+                )
+            );
     }
 
     /**
@@ -99,42 +95,59 @@ contract InterchainAccountRouter is Router, IInterchainAccountRouter {
      * @param _sender The parent account address on the origin domain.
      * @return The address of the interchain account.
      */
-    function getInterchainAccount(uint32 _origin, address _sender)
+    function getInterchainAccount(uint32 _origin, bytes32 _sender)
         public
         view
-        returns (address)
+        returns (address payable)
     {
         return _getInterchainAccount(_salt(_origin, _sender));
     }
 
+    function getInterchainAccount(uint32 _origin, address _sender)
+        external
+        view
+        returns (address payable)
+    {
+        return getInterchainAccount(_origin, _sender.addressToBytes32());
+    }
+
     /**
      * @notice Returns and deploys (if not already) the interchain account for a given `origin`/`sender` pair.
      * @param _origin The origin domain of the interchain account.
      * @param _sender The parent account address on the origin domain.
      * @return The address of the interchain account.
      */
-    function getDeployedInterchainAccount(uint32 _origin, address _sender)
+    function getDeployedInterchainAccount(uint32 _origin, bytes32 _sender)
         public
         returns (OwnableMulticall)
     {
         bytes32 salt = _salt(_origin, _sender);
-        address interchainAccount = _getInterchainAccount(salt);
+        address payable interchainAccount = _getInterchainAccount(salt);
         if (!Address.isContract(interchainAccount)) {
             bytes memory bytecode = MinimalProxy.bytecode(implementation);
-            interchainAccount = Create2.deploy(0, salt, bytecode);
-            OwnableMulticall(interchainAccount).initialize();
+            interchainAccount = payable(Create2.deploy(0, salt, bytecode));
             emit InterchainAccountCreated(_origin, _sender, interchainAccount);
+            // transfers ownership to this contract
+            OwnableMulticall(interchainAccount).initialize();
         }
         return OwnableMulticall(interchainAccount);
     }
 
+    function getDeployedInterchainAccount(uint32 _origin, address _sender)
+        public
+        returns (OwnableMulticall)
+    {
+        return
+            getDeployedInterchainAccount(_origin, _sender.addressToBytes32());
+    }
+
     /**
      * @notice Returns the salt used to deploy the interchain account for a given `origin`/`sender` pair.
      * @param _origin The origin domain of the interchain account.
      * @param _sender The parent account address on the origin domain.
      * @return The CREATE2 salt used for deploying the interchain account.
      */
-    function _salt(uint32 _origin, address _sender)
+    function _salt(uint32 _origin, bytes32 _sender)
         internal
         pure
         returns (bytes32)
@@ -150,9 +163,9 @@ contract InterchainAccountRouter is Router, IInterchainAccountRouter {
     function _getInterchainAccount(bytes32 salt)
         internal
         view
-        returns (address)
+        returns (address payable)
     {
-        return Create2.computeAddress(salt, bytecodeHash);
+        return payable(Create2.computeAddress(salt, bytecodeHash));
     }
 
     /**
@@ -165,10 +178,10 @@ contract InterchainAccountRouter is Router, IInterchainAccountRouter {
         bytes32, // router sender
         bytes calldata _message
     ) internal override {
-        (address sender, CallLib.Call[] memory calls) = abi.decode(
-            _message,
-            (address, CallLib.Call[])
+        OwnableMulticall interchainAccount = getDeployedInterchainAccount(
+            _origin,
+            InterchainCallMessage.sender(_message)
         );
-        getDeployedInterchainAccount(_origin, sender).proxyCalls(calls);
+        interchainAccount.proxyCalls(InterchainCallMessage.calls(_message));
     }
 }

package/contracts/middleware/InterchainCallMessage.sol

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.13;
+
+import {CallLib} from "../libs/Call.sol";
+
+/**
+ * Format of metadata:
+ * [   0: 32] Sender address
+ * [   32:64] Call type (left padded with zeroes)
+ * [  64:???] Encoded call array
+ */
+library InterchainCallMessage {
+    uint256 private constant SENDER_OFFSET = 0;
+    uint256 private constant TYPE_OFFSET = 32;
+    uint256 private constant CALLS_OFFSET = 64;
+
+    enum CallType {
+        CALL,
+        STATIC_CALL,
+        STATIC_CALL_WITH_CALLBACK,
+        RAW_CALLDATA
+    }
+
+    function sender(bytes calldata _message) internal pure returns (bytes32) {
+        return bytes32(_message[SENDER_OFFSET:TYPE_OFFSET]);
+    }
+
+    function calltype(bytes calldata _message)
+        internal
+        pure
+        returns (CallType)
+    {
+        // left padded with zeroes
+        return CallType(uint8(bytes1(_message[CALLS_OFFSET - 1])));
+    }
+
+    function format(CallLib.Call[] calldata _calls, bytes32 _sender)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encode(_sender, CallType.CALL, _calls);
+    }
+
+    function calls(bytes calldata _message)
+        internal
+        pure
+        returns (CallLib.Call[] memory _calls)
+    {
+        assert(calltype(_message) == CallType.CALL);
+        (, , _calls) = abi.decode(
+            _message,
+            (bytes32, CallType, CallLib.Call[])
+        );
+    }
+
+    function format(CallLib.StaticCall[] calldata _calls, bytes32 _sender)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encode(_sender, CallType.STATIC_CALL, _calls);
+    }
+
+    function staticCalls(bytes calldata _message)
+        internal
+        pure
+        returns (CallLib.StaticCall[] memory _calls)
+    {
+        assert(calltype(_message) == CallType.STATIC_CALL);
+        (, , _calls) = abi.decode(
+            _message,
+            (bytes32, CallType, CallLib.StaticCall[])
+        );
+    }
+
+    function format(
+        CallLib.StaticCallWithCallback[] calldata _calls,
+        bytes32 _sender
+    ) internal pure returns (bytes memory) {
+        return abi.encode(_sender, CallType.STATIC_CALL_WITH_CALLBACK, _calls);
+    }
+
+    function callsWithCallbacks(bytes calldata _message)
+        internal
+        pure
+        returns (CallLib.StaticCallWithCallback[] memory _calls)
+    {
+        assert(calltype(_message) == CallType.STATIC_CALL_WITH_CALLBACK);
+        (, , _calls) = abi.decode(
+            _message,
+            (bytes32, CallType, CallLib.StaticCallWithCallback[])
+        );
+    }
+
+    function format(bytes[] memory _calls, bytes32 _sender)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encode(_sender, CallType.RAW_CALLDATA, _calls);
+    }
+
+    function rawCalls(bytes calldata _message)
+        internal
+        pure
+        returns (bytes[] memory _calls)
+    {
+        assert(calltype(_message) == CallType.RAW_CALLDATA);
+        (, , _calls) = abi.decode(_message, (bytes32, CallType, bytes[]));
+    }
+}