@hyperlane-xyz/core 1.0.0 → 1.1.0-beta0

package/contracts/Mailbox.sol

@@ -107,7 +107,6 @@ contract Mailbox is
 
     // ============ Constructor ============
 
-    // solhint-disable-next-line no-empty-blocks
     constructor(uint32 _localDomain) {
         localDomain = _localDomain;
     }

package/contracts/OwnableMulticall.sol

@@ -4,38 +4,16 @@ pragma solidity ^0.8.13;
 // ============ External Imports ============
 
 import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
-import {Call} from "./Call.sol";
-
-function _call(Call[] memory calls, bytes[] memory callbacks)
-    returns (bytes[] memory resolveCalls)
-{
-    resolveCalls = new bytes[](callbacks.length);
-    for (uint256 i = 0; i < calls.length; i++) {
-        (bool success, bytes memory returnData) = calls[i].to.call(
-            calls[i].data
-        );
-        require(success, "Multicall: call failed");
-        resolveCalls[i] = bytes.concat(callbacks[i], returnData);
-    }
-}
-
-// TODO: deduplicate
-function _proxyCallBatch(address to, bytes[] memory calls) {
-    for (uint256 i = 0; i < calls.length; i += 1) {
-        (bool success, bytes memory returnData) = to.call(calls[i]);
-        if (!success) {
-            assembly {
-                revert(add(returnData, 32), returnData)
-            }
-        }
-    }
-}
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {CallLib} from "./libs/Call.sol";
 
 /*
  * @title OwnableMulticall
  * @dev Allows only only address to execute calls to other contracts
  */
 contract OwnableMulticall is OwnableUpgradeable {
+    using CallLib for CallLib.Call[];
+
     constructor() {
         _transferOwnership(msg.sender);
     }
@@ -44,16 +22,7 @@ contract OwnableMulticall is OwnableUpgradeable {
         __Ownable_init();
     }
 
-    function proxyCalls(Call[] calldata calls) external onlyOwner {
-        for (uint256 i = 0; i < calls.length; i += 1) {
-            (bool success, bytes memory returnData) = calls[i].to.call(
-                calls[i].data
-            );
-            if (!success) {
-                assembly {
-                    revert(add(returnData, 32), returnData)
-                }
-            }
-        }
+    function proxyCalls(CallLib.Call[] calldata calls) external onlyOwner {
+        calls._multicall();
     }
 }

package/contracts/ValidatorAnnounce.sol

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+import {IValidatorAnnounce} from "../interfaces/IValidatorAnnounce.sol";
+import {IMailbox} from "../interfaces/IMailbox.sol";
+import {TypeCasts} from "./libs/TypeCasts.sol";
+import {ValidatorAnnouncements} from "./libs/ValidatorAnnouncements.sol";
+// ============ External Imports ============
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+
+/**
+ * @title ValidatorAnnounce
+ * @notice Stores the location(s) of validator signed checkpoints
+ */
+contract ValidatorAnnounce is IValidatorAnnounce {
+    // ============ Libraries ============
+
+    using EnumerableSet for EnumerableSet.AddressSet;
+    using TypeCasts for address;
+
+    // ============ Constants ============
+
+    // Address of the mailbox being validated
+    address public immutable mailbox;
+    // Domain of chain on which the contract is deployed
+    uint32 public immutable localDomain;
+
+    // ============ Public Storage ============
+
+    // The set of validators that have announced
+    EnumerableSet.AddressSet private validators;
+    // Storage locations of validator signed checkpoints
+    mapping(address => string[]) private storageLocations;
+    // Mapping to prevent the same announcement from being registered
+    // multiple times.
+    mapping(bytes32 => bool) private replayProtection;
+
+    // ============ Events ============
+
+    /**
+     * @notice Emitted when a new validator announcement is made
+     * @param validator The address of the announcing validator
+     * @param storageLocation The storage location being announced
+     */
+    event ValidatorAnnouncement(
+        address indexed validator,
+        string storageLocation
+    );
+
+    // ============ Constructor ============
+
+    constructor(address _mailbox) {
+        mailbox = _mailbox;
+        localDomain = IMailbox(mailbox).localDomain();
+    }
+
+    // ============ External Functions ============
+
+    /**
+     * @notice Announces a validator signature storage location
+     * @param _storageLocation Information encoding the location of signed
+     * checkpoints
+     * @param _signature The signed validator announcement
+     * @return True upon success
+     */
+    function announce(
+        address _validator,
+        string calldata _storageLocation,
+        bytes calldata _signature
+    ) external returns (bool) {
+        // Ensure that the same storage metadata isn't being announced
+        // multiple times for the same validator.
+        bytes32 _replayId = keccak256(
+            abi.encodePacked(_validator, _storageLocation)
+        );
+        require(replayProtection[_replayId] == false, "replay");
+        replayProtection[_replayId] = true;
+
+        // Verify that the signature matches the declared validator
+        bytes32 _announcementDigest = ValidatorAnnouncements
+            .getAnnouncementDigest(mailbox, localDomain, _storageLocation);
+        address _signer = ECDSA.recover(_announcementDigest, _signature);
+        require(_signer == _validator, "!signature");
+
+        // Store the announcement
+        if (!validators.contains(_validator)) {
+            validators.add(_validator);
+        }
+        storageLocations[_validator].push(_storageLocation);
+        emit ValidatorAnnouncement(_validator, _storageLocation);
+        return true;
+    }
+
+    /**
+     * @notice Returns a list of all announced storage locations
+     * @param _validators The list of validators to get registrations for
+     * @return A list of registered storage metadata
+     */
+    function getAnnouncedStorageLocations(address[] calldata _validators)
+        external
+        view
+        returns (string[][] memory)
+    {
+        string[][] memory _metadata = new string[][](_validators.length);
+        for (uint256 i = 0; i < _validators.length; i++) {
+            _metadata[i] = storageLocations[_validators[i]];
+        }
+        return _metadata;
+    }
+
+    /// @notice Returns a list of validators that have made announcements
+    function getAnnouncedValidators() external view returns (address[] memory) {
+        return validators.values();
+    }
+}

package/contracts/{InterchainGasPaymaster.sol → igps/InterchainGasPaymaster.sol}

@@ -2,7 +2,7 @@
 pragma solidity >=0.8.0;
 
 // ============ Internal Imports ============
-import {IInterchainGasPaymaster} from "../interfaces/IInterchainGasPaymaster.sol";
+import {IInterchainGasPaymaster} from "../../interfaces/IInterchainGasPaymaster.sol";
 // ============ External Imports ============
 import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 
@@ -28,7 +28,6 @@ contract InterchainGasPaymaster is IInterchainGasPaymaster, OwnableUpgradeable {
 
     // ============ Constructor ============
 
-    // solhint-disable-next-line no-empty-blocks
     constructor() {
         initialize(); // allows contract to be used without proxying
     }
@@ -42,6 +41,8 @@ contract InterchainGasPaymaster is IInterchainGasPaymaster, OwnableUpgradeable {
     /**
      * @notice Deposits msg.value as a payment for the relaying of a message
      * to its destination chain.
+     * @dev Overpayment will result in a refund of native tokens to the _refundAddress.
+     * Callers should be aware that this may present reentrancy issues.
      * @param _messageId The ID of the message to pay for.
      * @param _destinationDomain The domain of the message's destination chain.
      * @param _gasAmount The amount of destination gas to pay for. Currently unused.
@@ -64,7 +65,6 @@ contract InterchainGasPaymaster is IInterchainGasPaymaster, OwnableUpgradeable {
         uint256 _overpayment = msg.value - _requiredPayment;
         if (_overpayment > 0) {
             (bool _success, ) = _refundAddress.call{value: _overpayment}("");
-            // TODO reconsider this?
             require(_success, "Interchain gas payment refund failed");
         }
 

package/contracts/igps/OverheadIgp.sol

@@ -0,0 +1,133 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+import {IInterchainGasPaymaster} from "../../interfaces/IInterchainGasPaymaster.sol";
+// ============ External Imports ============
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+
+/**
+ * @notice An IGP that adds configured gas overheads to gas amounts and forwards
+ * calls to an "inner" IGP.
+ * @dev The intended use of this contract is to store overhead gas amounts for destination
+ * domains, e.g. Mailbox and/or ISM gas usage, such that users of this IGP are only required
+ * to specify the gas amount used by their own applications.
+ */
+contract OverheadIgp is IInterchainGasPaymaster, Ownable {
+    // ============ Constants ============
+
+    /// @notice The IGP that is called when paying for or quoting gas
+    /// after applying overhead gas amounts.
+    IInterchainGasPaymaster public immutable innerIgp;
+
+    // ============ Public Storage ============
+
+    /// @notice Destination domain => overhead gas amount on that domain.
+    mapping(uint32 => uint256) public destinationGasOverhead;
+
+    // ============ Events ============
+
+    /**
+     * @notice Emitted when an entry in the destinationGasOverhead mapping is set.
+     * @param domain The destination domain.
+     * @param gasOverhead The gas overhead amount on that domain.
+     */
+    event DestinationGasOverheadSet(uint32 indexed domain, uint256 gasOverhead);
+
+    struct DomainConfig {
+        uint32 domain;
+        uint256 gasOverhead;
+    }
+
+    // ============ Constructor ============
+
+    constructor(address _innerIgp) {
+        innerIgp = IInterchainGasPaymaster(_innerIgp);
+    }
+
+    // ============ External Functions ============
+
+    /**
+     * @notice Adds the stored destinationGasOverhead to the _gasAmount and forwards the
+     * call to the innerIgp's `payForGas` function.
+     * @param _messageId The ID of the message to pay for.
+     * @param _destinationDomain The domain of the message's destination chain.
+     * @param _gasAmount The amount of destination gas to pay for. This should not
+     * consider any gas that is accounted for in the stored destinationGasOverhead.
+     * @param _refundAddress The address to refund any overpayment to.
+     */
+    function payForGas(
+        bytes32 _messageId,
+        uint32 _destinationDomain,
+        uint256 _gasAmount,
+        address _refundAddress
+    ) external payable {
+        innerIgp.payForGas{value: msg.value}(
+            _messageId,
+            _destinationDomain,
+            destinationGasAmount(_destinationDomain, _gasAmount),
+            _refundAddress
+        );
+    }
+
+    /**
+     * @notice Sets destination gas overheads for multiple domains.
+     * @dev Only callable by the owner.
+     * @param configs A list of destination domains and gas overheads.
+     */
+    function setDestinationGasOverheads(DomainConfig[] calldata configs)
+        external
+        onlyOwner
+    {
+        for (uint256 i; i < configs.length; i++) {
+            _setDestinationGasOverhead(configs[i]);
+        }
+    }
+
+    // ============ Public Functions ============
+
+    /**
+     * @notice Adds the stored destinationGasOverhead to the _gasAmount and forwards the
+     * call to the innerIgp's `quoteGasPayment` function.
+     * @param _destinationDomain The domain of the message's destination chain.
+     * @param _gasAmount The amount of destination gas to pay for. This should not
+     * consider any gas that is accounted for in the stored destinationGasOverhead.
+     * @return The amount of native tokens required to pay for interchain gas.
+     */
+    function quoteGasPayment(uint32 _destinationDomain, uint256 _gasAmount)
+        public
+        view
+        returns (uint256)
+    {
+        return
+            innerIgp.quoteGasPayment(
+                _destinationDomain,
+                destinationGasAmount(_destinationDomain, _gasAmount)
+            );
+    }
+
+    /**
+     * @notice Returns the stored destinationGasOverhead added to the _gasAmount.
+     * @dev If there is no stored destinationGasOverhead, 0 is used.
+     * @param _destinationDomain The domain of the message's destination chain.
+     * @param _gasAmount The amount of destination gas to pay for. This should not
+     * consider any gas that is accounted for in the stored destinationGasOverhead.
+     * @return The stored destinationGasOverhead added to the _gasAmount.
+     */
+    function destinationGasAmount(uint32 _destinationDomain, uint256 _gasAmount)
+        public
+        view
+        returns (uint256)
+    {
+        return destinationGasOverhead[_destinationDomain] + _gasAmount;
+    }
+
+    /**
+     * @notice Sets the destination gas overhead for a single domain.
+     * @param config The destination domain and gas overhead.
+     */
+    function _setDestinationGasOverhead(DomainConfig calldata config) internal {
+        destinationGasOverhead[config.domain] = config.gasOverhead;
+        emit DestinationGasOverheadSet(config.domain, config.gasOverhead);
+    }
+}

package/contracts/libs/Call.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.13;
+
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+
+library CallLib {
+    struct Call {
+        address to;
+        bytes data;
+    }
+
+    function _multicall(address to, bytes[] memory calls) internal {
+        uint256 i = 0;
+        uint256 len = calls.length;
+        while (i < len) {
+            Address.functionCall(to, calls[i]);
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function _multicall(Call[] memory calls) internal {
+        uint256 i = 0;
+        uint256 len = calls.length;
+        while (i < len) {
+            Address.functionCall(calls[i].to, calls[i].data);
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function _multicallAndResolve(Call[] memory calls, bytes[] memory callbacks)
+        internal
+        returns (bytes[] memory resolveCalls)
+    {
+        // reuse memory
+        resolveCalls = callbacks;
+
+        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);
+            unchecked {
+                ++i;
+            }
+        }
+    }
+}

package/contracts/libs/ValidatorAnnouncements.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+// ============ Internal Imports ============
+import {TypeCasts} from "./TypeCasts.sol";
+// ============ External Imports ============
+import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+
+library ValidatorAnnouncements {
+    using TypeCasts for address;
+
+    /**
+     * @notice Returns the digest validators are expected to sign when signing announcements.
+     * @param _mailbox Address of the mailbox being validated
+     * @param _localDomain Domain of chain on which the contract is deployed
+     * @param _storageLocation Storage location string.
+     * @return The digest of the announcement.
+     */
+    function getAnnouncementDigest(
+        address _mailbox,
+        uint32 _localDomain,
+        string memory _storageLocation
+    ) internal pure returns (bytes32) {
+        bytes32 _domainHash = keccak256(
+            abi.encodePacked(
+                _localDomain,
+                _mailbox.addressToBytes32(),
+                "HYPERLANE"
+            )
+        );
+        return
+            ECDSA.toEthSignedMessageHash(
+                keccak256(abi.encodePacked(_domainHash, _storageLocation))
+            );
+    }
+}

package/contracts/middleware/InterchainAccountRouter.sol

@@ -2,10 +2,11 @@
 pragma solidity ^0.8.13;
 
 // ============ Internal Imports ============
-import {OwnableMulticall, Call} from "../OwnableMulticall.sol";
+import {OwnableMulticall} from "../OwnableMulticall.sol";
 import {Router} from "../Router.sol";
 import {IInterchainAccountRouter} from "../../interfaces/IInterchainAccountRouter.sol";
 import {MinimalProxy} from "../libs/MinimalProxy.sol";
+import {CallLib} from "../libs/Call.sol";
 
 // ============ External Imports ============
 import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
@@ -68,7 +69,7 @@ contract InterchainAccountRouter is Router, IInterchainAccountRouter {
      * @param _destinationDomain The domain of the chain where the message will be sent to.
      * @param calls The sequence of calls to be relayed.
      */
-    function dispatch(uint32 _destinationDomain, Call[] calldata calls)
+    function dispatch(uint32 _destinationDomain, CallLib.Call[] calldata calls)
         external
         returns (bytes32)
     {
@@ -87,8 +88,8 @@ contract InterchainAccountRouter is Router, IInterchainAccountRouter {
         address target,
         bytes calldata data
     ) external returns (bytes32) {
-        Call[] memory calls = new Call[](1);
-        calls[0] = Call({to: target, data: data});
+        CallLib.Call[] memory calls = new CallLib.Call[](1);
+        calls[0] = CallLib.Call({to: target, data: data});
         return _dispatch(_destinationDomain, abi.encode(msg.sender, calls));
     }
 
@@ -164,9 +165,9 @@ contract InterchainAccountRouter is Router, IInterchainAccountRouter {
         bytes32, // router sender
         bytes calldata _message
     ) internal override {
-        (address sender, Call[] memory calls) = abi.decode(
+        (address sender, CallLib.Call[] memory calls) = abi.decode(
             _message,
-            (address, Call[])
+            (address, CallLib.Call[])
         );
         getDeployedInterchainAccount(_origin, sender).proxyCalls(calls);
     }

package/contracts/middleware/InterchainQueryRouter.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.13;
 
 // ============ Internal Imports ============
-import {_call, _proxyCallBatch, Call} from "../OwnableMulticall.sol";
+import {CallLib} from "../libs/Call.sol";
 import {Router} from "../Router.sol";
 import {IInterchainQueryRouter} from "../../interfaces/IInterchainQueryRouter.sol";
 
@@ -16,6 +16,9 @@ import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Ini
  * @dev Currently does not support Sovereign Consensus (user specified Interchain Security Modules).
  */
 contract InterchainQueryRouter is Router, IInterchainQueryRouter {
+    using CallLib for address;
+    using CallLib for CallLib.Call[];
+
     enum Action {
         DISPATCH,
         RESOLVE
@@ -81,8 +84,8 @@ contract InterchainQueryRouter is Router, IInterchainQueryRouter {
         bytes calldata callback
     ) external returns (bytes32 messageId) {
         // TODO: fix this ugly arrayification
-        Call[] memory calls = new Call[](1);
-        calls[0] = Call({to: target, data: queryData});
+        CallLib.Call[] memory calls = new CallLib.Call[](1);
+        calls[0] = CallLib.Call({to: target, data: queryData});
         bytes[] memory callbacks = new bytes[](1);
         callbacks[0] = callback;
         messageId = query(_destinationDomain, calls, callbacks);
@@ -95,11 +98,11 @@ contract InterchainQueryRouter is Router, IInterchainQueryRouter {
      */
     function query(
         uint32 _destinationDomain,
-        Call calldata call,
+        CallLib.Call calldata call,
         bytes calldata callback
     ) external returns (bytes32 messageId) {
         // TODO: fix this ugly arrayification
-        Call[] memory calls = new Call[](1);
+        CallLib.Call[] memory calls = new CallLib.Call[](1);
         calls[0] = call;
         bytes[] memory callbacks = new bytes[](1);
         callbacks[0] = callback;
@@ -113,7 +116,7 @@ contract InterchainQueryRouter is Router, IInterchainQueryRouter {
      */
     function query(
         uint32 _destinationDomain,
-        Call[] memory calls,
+        CallLib.Call[] memory calls,
         bytes[] memory callbacks
     ) public returns (bytes32 messageId) {
         require(
@@ -142,21 +145,21 @@ contract InterchainQueryRouter is Router, IInterchainQueryRouter {
             (
                 ,
                 address sender,
-                Call[] memory calls,
+                CallLib.Call[] memory calls,
                 bytes[] memory callbacks
-            ) = abi.decode(_message, (Action, address, Call[], bytes[]));
-            bytes[] memory resolveCallbacks = _call(calls, callbacks);
-            _dispatch(
-                _origin,
-                abi.encode(Action.RESOLVE, sender, resolveCallbacks)
-            );
+            ) = abi.decode(
+                    _message,
+                    (Action, address, CallLib.Call[], bytes[])
+                );
+            callbacks = calls._multicallAndResolve(callbacks);
+            _dispatch(_origin, abi.encode(Action.RESOLVE, sender, callbacks));
             emit QueryReturned(_origin, sender);
         } else if (action == Action.RESOLVE) {
             (, address sender, bytes[] memory resolveCallbacks) = abi.decode(
                 _message,
                 (Action, address, bytes[])
             );
-            _proxyCallBatch(sender, resolveCallbacks);
+            sender._multicall(resolveCallbacks);
             emit QueryResolved(_origin, sender);
         }
     }

package/contracts/mock/MockHyperlaneEnvironment.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.8.13;
 
 import "./MockMailbox.sol";
 import "../middleware/InterchainQueryRouter.sol";
-import "../InterchainGasPaymaster.sol";
+import "../igps/InterchainGasPaymaster.sol";
 import "../test/TestIsm.sol";
 
 import {TypeCasts} from "../libs/TypeCasts.sol";

package/contracts/mock/MockMailbox.sol

@@ -8,8 +8,8 @@ contract MockMailbox {
     using TypeCasts for address;
     using TypeCasts for bytes32;
     // Domain of chain on which the contract is deployed
-    uint32 public immutable domain;
-    uint32 public immutable version = 0;
+    uint32 public immutable localDomain;
+    uint32 public immutable VERSION = 0;
 
     uint256 public outboundNonce = 0;
     uint256 public inboundUnprocessedNonce = 0;
@@ -25,7 +25,7 @@ contract MockMailbox {
     }
 
     constructor(uint32 _domain) {
-        domain = _domain;
+        localDomain = _domain;
     }
 
     function addRemoteMailbox(uint32 _domain, MockMailbox _mailbox) external {
@@ -43,7 +43,7 @@ contract MockMailbox {
             "Missing remote mailbox"
         );
         _destinationMailbox.addInboundMessage(
-            domain,
+            localDomain,
             msg.sender,
             _recipientAddress.bytes32ToAddress(),
             _messageBody

package/contracts/test/LightTestRecipient.sol

@@ -0,0 +1,12 @@
+import "./TestRecipient.sol";
+
+contract LightTestRecipient is TestRecipient {
+    // solhint-disable-next-line no-empty-blocks
+    function handle(
+        uint32 _origin,
+        bytes32 _sender,
+        bytes calldata _data
+    ) external override {
+        // do nothing
+    }
+}

package/contracts/test/TestQuery.sol

@@ -2,7 +2,6 @@
 pragma solidity ^0.8.13;
 
 import {InterchainQueryRouter} from "../middleware/InterchainQueryRouter.sol";
-import {Call} from "../OwnableMulticall.sol";
 import {TypeCasts} from "../libs/TypeCasts.sol";
 
 contract TestQuery {
@@ -18,15 +17,13 @@ contract TestQuery {
      * @dev Fetches owner of InterchainQueryRouter on provided domain and passes along with provided secret to `this.receiveRouterOwner`
      */
     function queryRouterOwner(uint32 domain, uint256 secret) external {
-        Call memory call = Call({
-            to: TypeCasts.bytes32ToAddress(router.routers(domain)),
-            data: abi.encodeWithSignature("owner()")
-        });
+        address target = TypeCasts.bytes32ToAddress(router.routers(domain));
+        bytes memory data = abi.encodeWithSignature("owner()");
         bytes memory callback = bytes.concat(
             this.receiveRouterOwer.selector,
             bytes32(secret)
         );
-        router.query(domain, call, callback);
+        router.query(domain, target, data, callback);
     }
 
     /**