@hyperlane-xyz/core 1.4.3-beta1 → 1.5.0

package/contracts/Router.sol

@@ -70,21 +70,18 @@ abstract contract Router is HyperlaneConnectionClient, IMessageRecipient {
 
     // ============ External functions ============
     function domains() external view returns (uint32[] memory) {
-        bytes32[] storage rawKeys = _routers.keys();
-        uint256 length = rawKeys.length;
-        uint32[] memory keys = new uint32[](length);
-        for (uint256 i = 0; i < length; i++) {
-            keys[i] = uint32(uint256(rawKeys[i]));
-        }
-        return keys;
+        return _routers.uint32Keys();
     }
 
-    function routers(uint32 _domain) public view returns (bytes32) {
-        if (_routers.contains(_domain)) {
-            return _routers.get(_domain);
-        } else {
-            return bytes32(0); // for backwards compatibility with storage mapping
-        }
+    /**
+     * @notice Returns the address of the Router contract for the given domain
+     * @param _domain The remote domain ID.
+     * @dev Returns 0 address if no router is enrolled for the given domain
+     * @return router The address of the Router contract for the given domain
+     */
+    function routers(uint32 _domain) public view virtual returns (bytes32) {
+        (, bytes32 _router) = _routers.tryGet(_domain);
+        return _router;
     }
 
     /**
@@ -144,7 +141,10 @@ abstract contract Router is HyperlaneConnectionClient, IMessageRecipient {
      * @param _domain The domain
      * @param _address The new router
      */
-    function _enrollRemoteRouter(uint32 _domain, bytes32 _address) internal {
+    function _enrollRemoteRouter(uint32 _domain, bytes32 _address)
+        internal
+        virtual
+    {
         _routers.set(_domain, _address);
         emit RemoteRouterEnrolled(_domain, _address);
     }
@@ -170,10 +170,11 @@ abstract contract Router is HyperlaneConnectionClient, IMessageRecipient {
     function _mustHaveRemoteRouter(uint32 _domain)
         internal
         view
-        returns (bytes32 _router)
+        returns (bytes32)
     {
-        _router = routers(_domain);
-        require(_router != bytes32(0), NO_ROUTER_ENROLLED_REVERT_MESSAGE);
+        (bool contained, bytes32 _router) = _routers.tryGet(_domain);
+        require(contained, NO_ROUTER_ENROLLED_REVERT_MESSAGE);
+        return _router;
     }
 
     /**

package/contracts/igps/InterchainGasPaymaster.sol

@@ -5,6 +5,7 @@ pragma solidity >=0.8.0;
 import {IGasOracle} from "../interfaces/IGasOracle.sol";
 import {IInterchainGasPaymaster} from "../interfaces/IInterchainGasPaymaster.sol";
 // ============ External Imports ============
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
 import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 
 /**
@@ -174,7 +175,14 @@ contract InterchainGasPaymaster is
         returns (uint128 tokenExchangeRate, uint128 gasPrice)
     {
         IGasOracle _gasOracle = gasOracles[_destinationDomain];
-        require(address(_gasOracle) != address(0), "!gas oracle");
+
+        require(
+            address(_gasOracle) != address(0),
+            string.concat(
+                "Configured IGP doesn't support domain ",
+                Strings.toString(_destinationDomain)
+            )
+        );
 
         return _gasOracle.getExchangeRateAndGasPrice(_destinationDomain);
     }

package/contracts/isms/PausableIsm.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ External Imports ============
+import {Pausable} from "@openzeppelin/contracts/security/Pausable.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+
+// ============ Internal Imports ============
+import {IInterchainSecurityModule} from "../interfaces/IInterchainSecurityModule.sol";
+
+contract PausableIsm is IInterchainSecurityModule, Ownable, Pausable {
+    uint8 public constant override moduleType = uint8(Types.NULL);
+
+    /**
+     * @inheritdoc IInterchainSecurityModule
+     * @dev Reverts when paused, otherwise returns `true`.
+     */
+    function verify(bytes calldata, bytes calldata)
+        external
+        view
+        whenNotPaused
+        returns (bool)
+    {
+        return true;
+    }
+
+    function pause() external onlyOwner {
+        _pause();
+    }
+
+    function unpause() external onlyOwner {
+        _unpause();
+    }
+}

package/contracts/isms/routing/DefaultFallbackRoutingIsm.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {DomainRoutingIsm} from "./DomainRoutingIsm.sol";
+import {IMailbox} from "../../Mailbox.sol";
+import {IInterchainSecurityModule} from "../../interfaces/IInterchainSecurityModule.sol";
+import {EnumerableMapExtended} from "../../libs/EnumerableMapExtended.sol";
+import {TypeCasts} from "../../libs/TypeCasts.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+
+contract DefaultFallbackRoutingIsm is DomainRoutingIsm {
+    using EnumerableMapExtended for EnumerableMapExtended.UintToBytes32Map;
+    using Address for address;
+    using TypeCasts for bytes32;
+
+    IMailbox public immutable mailbox;
+
+    constructor(address _mailbox) {
+        require(
+            _mailbox.isContract(),
+            "DefaultFallbackRoutingIsm: INVALID_MAILBOX"
+        );
+        mailbox = IMailbox(_mailbox);
+    }
+
+    function modules(uint32 origin)
+        public
+        view
+        override
+        returns (IInterchainSecurityModule)
+    {
+        (bool contained, bytes32 _module) = _modules.tryGet(origin);
+        if (contained) {
+            return IInterchainSecurityModule(_module.bytes32ToAddress());
+        } else {
+            return mailbox.defaultIsm();
+        }
+    }
+}

package/contracts/isms/routing/DomainRoutingIsm.sol

@@ -8,13 +8,21 @@ import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/Own
 import {AbstractRoutingIsm} from "./AbstractRoutingIsm.sol";
 import {IInterchainSecurityModule} from "../../interfaces/IInterchainSecurityModule.sol";
 import {Message} from "../../libs/Message.sol";
+import {TypeCasts} from "../../libs/TypeCasts.sol";
+import {EnumerableMapExtended} from "../../libs/EnumerableMapExtended.sol";
 
 /**
  * @title DomainRoutingIsm
  */
 contract DomainRoutingIsm is AbstractRoutingIsm, OwnableUpgradeable {
-    // ============ Public Storage ============
-    mapping(uint32 => IInterchainSecurityModule) public modules;
+    using EnumerableMapExtended for EnumerableMapExtended.UintToBytes32Map;
+    using Message for bytes;
+    using TypeCasts for bytes32;
+    using TypeCasts for address;
+    using Address for address;
+
+    // ============ Mutable Storage ============
+    EnumerableMapExtended.UintToBytes32Map internal _modules;
 
     // ============ Events ============
 
@@ -23,7 +31,7 @@ contract DomainRoutingIsm is AbstractRoutingIsm, OwnableUpgradeable {
      * @param domain The origin domain.
      * @param module The ISM to use.
      */
-    event ModuleSet(uint32 indexed domain, IInterchainSecurityModule module);
+    event ModuleSet(uint32 indexed domain, address module);
 
     // ============ External Functions ============
 
@@ -39,18 +47,18 @@ contract DomainRoutingIsm is AbstractRoutingIsm, OwnableUpgradeable {
      * @notice Sets the ISMs to be used for the specified origin domains
      * @param _owner The owner of the contract.
      * @param _domains The origin domains
-     * @param _modules The ISMs to use to verify messages
+     * @param __modules The ISMs to use to verify messages
      */
     function initialize(
         address _owner,
         uint32[] calldata _domains,
-        IInterchainSecurityModule[] calldata _modules
+        IInterchainSecurityModule[] calldata __modules
     ) public initializer {
         __Ownable_init();
-        require(_domains.length == _modules.length, "length mismatch");
+        require(_domains.length == __modules.length, "length mismatch");
         uint256 _length = _domains.length;
         for (uint256 i = 0; i < _length; ++i) {
-            _set(_domains[i], _modules[i]);
+            _set(_domains[i], address(__modules[i]));
         }
         _transferOwnership(_owner);
     }
@@ -64,11 +72,25 @@ contract DomainRoutingIsm is AbstractRoutingIsm, OwnableUpgradeable {
         external
         onlyOwner
     {
-        _set(_domain, _module);
+        _set(_domain, address(_module));
     }
 
-    // ============ Public Functions ============
+    function domains() external view returns (uint256[] memory) {
+        return _modules.keys();
+    }
+
+    function modules(uint32 origin)
+        public
+        view
+        virtual
+        returns (IInterchainSecurityModule)
+    {
+        (bool contained, bytes32 _module) = _modules.tryGet(origin);
+        require(contained, "No ISM found for origin domain");
+        return IInterchainSecurityModule(_module.bytes32ToAddress());
+    }
 
+    // ============ Public Functions ============
     /**
      * @notice Returns the ISM responsible for verifying _message
      * @dev Can change based on the content of _message
@@ -78,16 +100,10 @@ contract DomainRoutingIsm is AbstractRoutingIsm, OwnableUpgradeable {
     function route(bytes calldata _message)
         public
         view
-        virtual
         override
         returns (IInterchainSecurityModule)
     {
-        IInterchainSecurityModule module = modules[Message.origin(_message)];
-        require(
-            address(module) != address(0),
-            "No ISM found for origin domain"
-        );
-        return module;
+        return modules(_message.origin());
     }
 
     // ============ Internal Functions ============
@@ -97,9 +113,9 @@ contract DomainRoutingIsm is AbstractRoutingIsm, OwnableUpgradeable {
      * @param _domain The origin domain
      * @param _module The ISM to use to verify messages
      */
-    function _set(uint32 _domain, IInterchainSecurityModule _module) internal {
-        require(Address.isContract(address(_module)), "!contract");
-        modules[_domain] = _module;
+    function _set(uint32 _domain, address _module) internal {
+        require(_module.isContract(), "!contract");
+        _modules.set(_domain, _module.addressToBytes32());
         emit ModuleSet(_domain, _module);
     }
 }

package/contracts/isms/routing/DomainRoutingIsmFactory.sol

@@ -3,28 +3,17 @@ pragma solidity >=0.8.0;
 
 // ============ Internal Imports ============
 import {DomainRoutingIsm} from "./DomainRoutingIsm.sol";
+import {DefaultFallbackRoutingIsm} from "./DefaultFallbackRoutingIsm.sol";
 import {IInterchainSecurityModule} from "../../interfaces/IInterchainSecurityModule.sol";
 import {MinimalProxy} from "../../libs/MinimalProxy.sol";
 
-/**
- * @title DomainRoutingIsmFactory
- */
-contract DomainRoutingIsmFactory {
-    // ============ Immutables ============
-    address private immutable _implementation;
-
+abstract contract AbstractDomainRoutingIsmFactory {
     /**
      * @notice Emitted when a routing module is deployed
      * @param module The deployed ISM
      */
     event ModuleDeployed(DomainRoutingIsm module);
 
-    // ============ Constructor ============
-
-    constructor() {
-        _implementation = address(new DomainRoutingIsm());
-    }
-
     // ============ External Functions ============
 
     /**
@@ -37,10 +26,46 @@ contract DomainRoutingIsmFactory {
         IInterchainSecurityModule[] calldata _modules
     ) external returns (DomainRoutingIsm) {
         DomainRoutingIsm _ism = DomainRoutingIsm(
-            MinimalProxy.create(_implementation)
+            MinimalProxy.create(implementation())
         );
         emit ModuleDeployed(_ism);
         _ism.initialize(msg.sender, _domains, _modules);
         return _ism;
     }
+
+    // ============ Internal Functions ============
+
+    function implementation() internal view virtual returns (address);
+}
+
+/**
+ * @title DomainRoutingIsmFactory
+ */
+contract DomainRoutingIsmFactory is AbstractDomainRoutingIsmFactory {
+    // ============ Immutables ============
+    address internal immutable _implementation;
+
+    constructor() {
+        _implementation = address(new DomainRoutingIsm());
+    }
+
+    function implementation() internal view override returns (address) {
+        return _implementation;
+    }
+}
+
+/**
+ * @title DefaultFallbackRoutingIsmFactory
+ */
+contract DefaultFallbackRoutingIsmFactory is AbstractDomainRoutingIsmFactory {
+    // ============ Immutables ============
+    address internal immutable _implementation;
+
+    constructor(address mailbox) {
+        _implementation = address(new DefaultFallbackRoutingIsm(mailbox));
+    }
+
+    function implementation() internal view override returns (address) {
+        return _implementation;
+    }
 }

package/contracts/libs/EnumerableMapExtended.sol

@@ -3,11 +3,13 @@ pragma solidity >=0.6.11;
 
 // ============ External Imports ============
 import "@openzeppelin/contracts/utils/structs/EnumerableMap.sol";
+import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
 // extends EnumerableMap with uint256 => bytes32 type
 // modelled after https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.8.0/contracts/utils/structs/EnumerableMap.sol
 library EnumerableMapExtended {
     using EnumerableMap for EnumerableMap.Bytes32ToBytes32Map;
+    using EnumerableSet for EnumerableSet.Bytes32Set;
 
     struct UintToBytes32Map {
         EnumerableMap.Bytes32ToBytes32Map _inner;
@@ -17,9 +19,25 @@ library EnumerableMapExtended {
     function keys(UintToBytes32Map storage map)
         internal
         view
-        returns (bytes32[] storage)
+        returns (uint256[] memory _keys)
     {
-        return map._inner._keys._inner._values;
+        uint256 _length = map._inner.length();
+        _keys = new uint256[](_length);
+        for (uint256 i = 0; i < _length; i++) {
+            _keys[i] = uint256(map._inner._keys.at(i));
+        }
+    }
+
+    function uint32Keys(UintToBytes32Map storage map)
+        internal
+        view
+        returns (uint32[] memory _keys)
+    {
+        uint256[] memory uint256keys = keys(map);
+        _keys = new uint32[](uint256keys.length);
+        for (uint256 i = 0; i < uint256keys.length; i++) {
+            _keys[i] = uint32(uint256keys[i]);
+        }
     }
 
     function set(
@@ -38,6 +56,14 @@ library EnumerableMapExtended {
         return map._inner.get(bytes32(key));
     }
 
+    function tryGet(UintToBytes32Map storage map, uint256 key)
+        internal
+        view
+        returns (bool, bytes32)
+    {
+        return map._inner.tryGet(bytes32(key));
+    }
+
     function remove(UintToBytes32Map storage map, uint256 key)
         internal
         returns (bool)