@hyperlane-xyz/core 1.3.1 → 1.3.3

package/README.md

@@ -6,7 +6,6 @@ On-chain implementations of Hyperlane in Solidity.
 
 - `npm install --dev`
 - `brew install jq`   OR   `sudo apt-get install jq`
-- `npm install -g solhint`, check it is installed using `solhint --version`
 
 ## Build
 

package/contracts/Mailbox.sol

@@ -189,7 +189,7 @@ contract Mailbox is
      * @return root The root of the Mailbox's merkle tree.
      * @return index The index of the last element in the tree.
      */
-    function latestCheckpoint() public view returns (bytes32, uint32) {
+    function latestCheckpoint() external view returns (bytes32, uint32) {
         return (root(), count() - 1);
     }
 
@@ -241,6 +241,7 @@ contract Mailbox is
             if (address(_val) != address(0)) {
                 return _val;
             }
+            // solhint-disable-next-line no-empty-blocks
         } catch {}
         return defaultIsm;
     }

package/contracts/Router.sol

@@ -11,7 +11,7 @@ import {EnumerableMapExtended} from "./libs/EnumerableMapExtended.sol";
 abstract contract Router is HyperlaneConnectionClient, IMessageRecipient {
     using EnumerableMapExtended for EnumerableMapExtended.UintToBytes32Map;
 
-    string constant NO_ROUTER_ENROLLED_REVERT_MESSAGE =
+    string private constant NO_ROUTER_ENROLLED_REVERT_MESSAGE =
         "No router enrolled for domain. Did you specify the right domain ID?";
 
     // ============ Mutable Storage ============
@@ -71,8 +71,9 @@ abstract contract Router is HyperlaneConnectionClient, IMessageRecipient {
     // ============ External functions ============
     function domains() external view returns (uint32[] memory) {
         bytes32[] storage rawKeys = _routers.keys();
-        uint32[] memory keys = new uint32[](rawKeys.length);
-        for (uint256 i = 0; i < rawKeys.length; i++) {
+        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;
@@ -109,7 +110,8 @@ abstract contract Router is HyperlaneConnectionClient, IMessageRecipient {
         bytes32[] calldata _addresses
     ) external virtual onlyOwner {
         require(_domains.length == _addresses.length, "!length");
-        for (uint256 i = 0; i < _domains.length; i += 1) {
+        uint256 length = _domains.length;
+        for (uint256 i = 0; i < length; i += 1) {
             _enrollRemoteRouter(_domains[i], _addresses[i]);
         }
     }
@@ -125,7 +127,6 @@ abstract contract Router is HyperlaneConnectionClient, IMessageRecipient {
         bytes32 _sender,
         bytes calldata _message
     ) external virtual override onlyMailbox onlyRemoteRouter(_origin, _sender) {
-        // TODO: callbacks on success/failure
         _handle(_origin, _sender, _message);
     }
 

package/contracts/interfaces/IInterchainSecurityModule.sol

@@ -3,7 +3,7 @@ pragma solidity >=0.6.11;
 
 interface IInterchainSecurityModule {
     enum Types {
-        UNUSED_0,
+        UNUSED,
         ROUTING,
         AGGREGATION,
         LEGACY_MULTISIG,

package/contracts/interfaces/{IAggregationIsm.sol → isms/IAggregationIsm.sol}

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
-pragma solidity >=0.6.0;
+pragma solidity >=0.6.11;
 
-import {IInterchainSecurityModule} from "./IInterchainSecurityModule.sol";
+import {IInterchainSecurityModule} from "../IInterchainSecurityModule.sol";
 
 interface IAggregationIsm is IInterchainSecurityModule {
     /**

package/contracts/interfaces/isms/IMultisigIsm.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
-pragma solidity >=0.6.0;
+pragma solidity >=0.6.11;
 
 import {IInterchainSecurityModule} from "../IInterchainSecurityModule.sol";
 

package/contracts/interfaces/isms/IRoutingIsm.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {IInterchainSecurityModule} from "../IInterchainSecurityModule.sol";
+
+interface IRoutingIsm is IInterchainSecurityModule {
+    /**
+     * @notice Returns the ISM responsible for verifying _message
+     * @dev Can change based on the content of _message
+     * @param _message Formatted Hyperlane message (see Message.sol).
+     * @return module The ISM to use to verify _message
+     */
+    function route(bytes calldata _message)
+        external
+        view
+        returns (IInterchainSecurityModule);
+}

package/contracts/isms/aggregation/AbstractAggregationIsm.sol

@@ -6,7 +6,7 @@ import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 
 // ============ Internal Imports ============
 import {IInterchainSecurityModule} from "../../interfaces/IInterchainSecurityModule.sol";
-import {IAggregationIsm} from "../../interfaces/IAggregationIsm.sol";
+import {IAggregationIsm} from "../../interfaces/isms/IAggregationIsm.sol";
 import {AggregationIsmMetadata} from "../../libs/isms/AggregationIsmMetadata.sol";
 
 /**
@@ -17,8 +17,9 @@ import {AggregationIsmMetadata} from "../../libs/isms/AggregationIsmMetadata.sol
 abstract contract AbstractAggregationIsm is IAggregationIsm {
     // ============ Constants ============
 
+    // solhint-disable-next-line const-name-snakecase
     uint8 public constant moduleType =
-        uint8(IInterchainSecurityModule.Types.MULTISIG);
+        uint8(IInterchainSecurityModule.Types.AGGREGATION);
 
     // ============ Virtual Functions ============
     // ======= OVERRIDE THESE TO IMPLEMENT =======

package/contracts/isms/multisig/AbstractMultisigIsm.sol

@@ -20,6 +20,7 @@ import {MerkleLib} from "../../libs/Merkle.sol";
 abstract contract AbstractMultisigIsm is IMultisigIsm {
     // ============ Constants ============
 
+    // solhint-disable-next-line const-name-snakecase
     uint8 public constant moduleType =
         uint8(IInterchainSecurityModule.Types.MULTISIG);
 
@@ -109,12 +110,12 @@ abstract contract AbstractMultisigIsm is IMultisigIsm {
                 MultisigIsmMetadata.signatureAt(_metadata, i)
             );
             // Loop through remaining validators until we find a match
-            for (
-                ;
+            while (
                 _validatorIndex < _validatorCount &&
-                    _signer != _validators[_validatorIndex];
-                ++_validatorIndex
-            ) {}
+                _signer != _validators[_validatorIndex]
+            ) {
+                ++_validatorIndex;
+            }
             // Fail if we never found a match
             require(_validatorIndex < _validatorCount, "!threshold");
             ++_validatorIndex;

package/contracts/isms/multisig/LegacyMultisigIsm.sol

@@ -29,6 +29,7 @@ contract LegacyMultisigIsm is IMultisigIsm, Ownable {
 
     // ============ Constants ============
 
+    // solhint-disable-next-line const-name-snakecase
     uint8 public constant moduleType =
         uint8(IInterchainSecurityModule.Types.LEGACY_MULTISIG);
 
@@ -102,10 +103,12 @@ contract LegacyMultisigIsm is IMultisigIsm, Ownable {
         uint32[] calldata _domains,
         address[][] calldata _validators
     ) external onlyOwner {
-        require(_domains.length == _validators.length, "!length");
-        for (uint256 i = 0; i < _domains.length; i += 1) {
+        uint256 domainsLength = _domains.length;
+        require(domainsLength == _validators.length, "!length");
+        for (uint256 i = 0; i < domainsLength; i += 1) {
             address[] calldata _domainValidators = _validators[i];
-            for (uint256 j = 0; j < _domainValidators.length; j += 1) {
+            uint256 validatorsLength = _domainValidators.length;
+            for (uint256 j = 0; j < validatorsLength; j += 1) {
                 _enrollValidator(_domains[i], _domainValidators[j]);
             }
             _updateCommitment(_domains[i]);
@@ -155,8 +158,9 @@ contract LegacyMultisigIsm is IMultisigIsm, Ownable {
         uint32[] calldata _domains,
         uint8[] calldata _thresholds
     ) external onlyOwner {
-        require(_domains.length == _thresholds.length, "!length");
-        for (uint256 i = 0; i < _domains.length; i += 1) {
+        uint256 length = _domains.length;
+        require(length == _thresholds.length, "!length");
+        for (uint256 i = 0; i < length; i += 1) {
             setThreshold(_domains[i], _thresholds[i]);
         }
     }
@@ -202,7 +206,7 @@ contract LegacyMultisigIsm is IMultisigIsm, Ownable {
      * @param _message Formatted Hyperlane message (see Message.sol).
      */
     function verify(bytes calldata _metadata, bytes calldata _message)
-        public
+        external
         view
         returns (bool)
     {
@@ -340,12 +344,12 @@ contract LegacyMultisigIsm is IMultisigIsm, Ownable {
         for (uint256 i = 0; i < _threshold; ++i) {
             address _signer = ECDSA.recover(_digest, _metadata.signatureAt(i));
             // Loop through remaining validators until we find a match
-            for (
-                ;
+            while (
                 _validatorIndex < _validatorCount &&
-                    _signer != _metadata.validatorAt(_validatorIndex);
-                ++_validatorIndex
-            ) {}
+                _signer != _metadata.validatorAt(_validatorIndex)
+            ) {
+                ++_validatorIndex;
+            }
             // Fail if we never found a match
             require(_validatorIndex < _validatorCount, "!threshold");
             ++_validatorIndex;

package/contracts/isms/routing/AbstractRoutingIsm.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+import {IInterchainSecurityModule} from "../../interfaces/IInterchainSecurityModule.sol";
+import {IRoutingIsm} from "../../interfaces/isms/IRoutingIsm.sol";
+
+/**
+ * @title RoutingIsm
+ */
+abstract contract AbstractRoutingIsm is IRoutingIsm {
+    // ============ Constants ============
+
+    uint8 public constant moduleType =
+        uint8(IInterchainSecurityModule.Types.ROUTING);
+
+    // ============ Virtual Functions ============
+    // ======= OVERRIDE THESE TO IMPLEMENT =======
+
+    /**
+     * @notice Returns the ISM responsible for verifying _message
+     * @dev Can change based on the content of _message
+     * @param _message Formatted Hyperlane message (see Message.sol).
+     * @return module The ISM to use to verify _message
+     */
+    function route(bytes calldata _message)
+        public
+        view
+        virtual
+        returns (IInterchainSecurityModule);
+
+    // ============ Public Functions ============
+
+    /**
+     * @notice Routes _metadata and _message to the correct ISM
+     * @param _metadata ABI encoded module metadata
+     * @param _message Formatted Hyperlane message (see Message.sol).
+     */
+    function verify(bytes calldata _metadata, bytes calldata _message)
+        public
+        returns (bool)
+    {
+        return route(_message).verify(_metadata, _message);
+    }
+}

package/contracts/isms/routing/DomainRoutingIsm.sol

@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+// ============ External Imports ============
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+
+// ============ Internal Imports ============
+import {AbstractRoutingIsm} from "./AbstractRoutingIsm.sol";
+import {IInterchainSecurityModule} from "../../interfaces/IInterchainSecurityModule.sol";
+import {Message} from "../../libs/Message.sol";
+
+/**
+ * @title DomainRoutingIsm
+ */
+contract DomainRoutingIsm is AbstractRoutingIsm, OwnableUpgradeable {
+    // ============ Public Storage ============
+    mapping(uint32 => IInterchainSecurityModule) public modules;
+
+    // ============ Events ============
+
+    /**
+     * @notice Emitted when a module is set for a domain
+     * @param domain The origin domain.
+     * @param module The ISM to use.
+     */
+    event ModuleSet(uint32 indexed domain, IInterchainSecurityModule module);
+
+    // ============ External Functions ============
+
+    /**
+     * @param _owner The owner of the contract.
+     */
+    function initialize(address _owner) public initializer {
+        __Ownable_init();
+        _transferOwnership(_owner);
+    }
+
+    /**
+     * @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
+     */
+    function initialize(
+        address _owner,
+        uint32[] calldata _domains,
+        IInterchainSecurityModule[] calldata _modules
+    ) public initializer {
+        __Ownable_init();
+        require(_domains.length == _modules.length, "length mismatch");
+        uint256 _length = _domains.length;
+        for (uint256 i = 0; i < _length; ++i) {
+            _set(_domains[i], _modules[i]);
+        }
+        _transferOwnership(_owner);
+    }
+
+    /**
+     * @notice Sets the ISM to be used for the specified origin domain
+     * @param _domain The origin domain
+     * @param _module The ISM to use to verify messages
+     */
+    function set(uint32 _domain, IInterchainSecurityModule _module)
+        external
+        onlyOwner
+    {
+        _set(_domain, _module);
+    }
+
+    // ============ Public Functions ============
+
+    /**
+     * @notice Returns the ISM responsible for verifying _message
+     * @dev Can change based on the content of _message
+     * @param _message Formatted Hyperlane message (see Message.sol).
+     * @return module The ISM to use to verify _message
+     */
+    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;
+    }
+
+    // ============ Internal Functions ============
+
+    /**
+     * @notice Sets the ISM to be used for the specified origin domain
+     * @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;
+        emit ModuleSet(_domain, _module);
+    }
+}

package/contracts/isms/routing/DomainRoutingIsmFactory.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+import {DomainRoutingIsm} from "./DomainRoutingIsm.sol";
+import {IInterchainSecurityModule} from "../../interfaces/IInterchainSecurityModule.sol";
+import {MinimalProxy} from "../../libs/MinimalProxy.sol";
+
+/**
+ * @title DomainRoutingIsmFactory
+ */
+contract DomainRoutingIsmFactory {
+    // ============ Immutables ============
+    address private immutable _implementation;
+
+    /**
+     * @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 ============
+
+    /**
+     * @notice Deploys and initializes a DomainRoutingIsm using a minimal proxy
+     * @param _domains The origin domains
+     * @param _modules The ISMs to use to verify messages
+     */
+    function deploy(
+        uint32[] calldata _domains,
+        IInterchainSecurityModule[] calldata _modules
+    ) external returns (DomainRoutingIsm) {
+        DomainRoutingIsm _ism = DomainRoutingIsm(
+            MinimalProxy.create(_implementation)
+        );
+        emit ModuleDeployed(_ism);
+        _ism.initialize(msg.sender, _domains, _modules);
+        return _ism;
+    }
+}

package/contracts/isms/routing/InterchainAccountIsm.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+// ============ Internal Imports ============
+import {AbstractRoutingIsm} from "./AbstractRoutingIsm.sol";
+import {IMailbox} from "../../interfaces/IMailbox.sol";
+import {IInterchainSecurityModule} from "../../interfaces/IInterchainSecurityModule.sol";
+import {Message} from "../../libs/Message.sol";
+import {InterchainAccountMessage} from "../../libs/middleware/InterchainAccountMessage.sol";
+
+/**
+ * @title InterchainAccountIsm
+ */
+contract InterchainAccountIsm is AbstractRoutingIsm {
+    IMailbox private immutable mailbox;
+
+    // ============ Constructor ============
+    constructor(address _mailbox) {
+        mailbox = IMailbox(_mailbox);
+    }
+
+    // ============ Public Functions ============
+
+    /**
+     * @notice Returns the ISM responsible for verifying _message
+     * @param _message Formatted Hyperlane message (see Message.sol).
+     * @return module The ISM to use to verify _message
+     */
+    function route(bytes calldata _message)
+        public
+        view
+        virtual
+        override
+        returns (IInterchainSecurityModule)
+    {
+        address _ism = InterchainAccountMessage.ism(Message.body(_message));
+        if (_ism == address(0)) {
+            return mailbox.defaultIsm();
+        } else {
+            return IInterchainSecurityModule(_ism);
+        }
+    }
+}

package/contracts/libs/MetaProxy.sol

@@ -3,9 +3,9 @@ pragma solidity >=0.7.6;
 
 /// @dev Adapted from https://eips.ethereum.org/EIPS/eip-3448
 library MetaProxy {
-    bytes32 constant PREFIX =
+    bytes32 private constant PREFIX =
         hex"600b380380600b3d393df3363d3d373d3d3d3d60368038038091363936013d73";
-    bytes13 constant SUFFIX = hex"5af43d3d93803e603457fd5bf3";
+    bytes13 private constant SUFFIX = hex"5af43d3d93803e603457fd5bf3";
 
     function bytecode(address _implementation, bytes memory _metadata)
         internal

package/contracts/libs/MinimalProxy.sol

@@ -3,8 +3,16 @@ pragma solidity >=0.6.11;
 
 // Library for building bytecode of minimal proxies (see https://eips.ethereum.org/EIPS/eip-1167)
 library MinimalProxy {
-    bytes20 constant PREFIX = hex"3d602d80600a3d3981f3363d3d373d3d3d363d73";
-    bytes15 constant SUFFIX = hex"5af43d82803e903d91602b57fd5bf3";
+    bytes20 private constant PREFIX =
+        hex"3d602d80600a3d3981f3363d3d373d3d3d363d73";
+    bytes15 private constant SUFFIX = hex"5af43d82803e903d91602b57fd5bf3";
+
+    function create(address implementation) internal returns (address proxy) {
+        bytes memory _bytecode = bytecode(implementation);
+        assembly {
+            proxy := create(0, add(_bytecode, 32), mload(_bytecode))
+        }
+    }
 
     function bytecode(address implementation)
         internal

package/contracts/libs/middleware/InterchainAccountMessage.sol

@@ -83,4 +83,13 @@ library InterchainAccountMessage {
     {
         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/InterchainQueryRouter.sol

@@ -136,7 +136,6 @@ contract InterchainQueryRouter is Router, IInterchainQueryRouter {
             address senderAddress = sender.bytes32ToAddress();
             bytes[] memory rawCalls = InterchainQueryMessage.rawCalls(_message);
             CallLib.multicallto(senderAddress, rawCalls);
-            //
             emit QueryResolved(_origin, senderAddress);
         } else {
             assert(false);

package/contracts/middleware/liquidity-layer/LiquidityLayerRouter.sol

@@ -11,8 +11,11 @@ import {ILiquidityLayerMessageRecipient} from "../../interfaces/ILiquidityLayerM
 import {TypeCasts} from "../../libs/TypeCasts.sol";
 
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 contract LiquidityLayerRouter is Router, ILiquidityLayerRouter {
+    using SafeERC20 for IERC20;
+
     // Token bridge => adapter address
     mapping(string => address) public liquidityLayerAdapters;
 
@@ -50,12 +53,7 @@ contract LiquidityLayerRouter is Router, ILiquidityLayerRouter {
         ILiquidityLayerAdapter _adapter = _getAdapter(_bridge);
 
         // Transfer the tokens to the adapter
-        // TODO: use safeTransferFrom
-        // TODO: Are there scenarios where a transferFrom fails and it doesn't revert?
-        require(
-            IERC20(_token).transferFrom(msg.sender, address(_adapter), _amount),
-            "!transfer in"
-        );
+        IERC20(_token).safeTransferFrom(msg.sender, address(_adapter), _amount);
 
         // Reverts if the bridge was unsuccessful.
         // Gets adapter-specific data that is encoded into the message

package/contracts/middleware/liquidity-layer/adapters/CircleBridgeAdapter.sol

@@ -8,8 +8,11 @@ import {ICircleMessageTransmitter} from "../interfaces/circle/ICircleMessageTran
 import {ILiquidityLayerAdapter} from "../interfaces/ILiquidityLayerAdapter.sol";
 
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 contract CircleBridgeAdapter is ILiquidityLayerAdapter, Router {
+    using SafeERC20 for IERC20;
+
     /// @notice The TokenMessenger contract.
     ITokenMessenger public tokenMessenger;
 
@@ -22,7 +25,7 @@ contract CircleBridgeAdapter is ILiquidityLayerAdapter, Router {
     /// @notice Hyperlane domain => Circle domain.
     /// ATM, known Circle domains are Ethereum = 0 and Avalanche = 1.
     /// Note this could result in ambiguity between the Circle domain being
-    /// Ethereum or unknown. TODO fix?
+    /// Ethereum or unknown.
     mapping(uint32 => uint32) public hyperlaneDomainToCircleDomain;
 
     /// @notice Token symbol => address of token on local chain.
@@ -70,8 +73,8 @@ contract CircleBridgeAdapter is ILiquidityLayerAdapter, Router {
         address _tokenMessenger,
         address _circleMessageTransmitter,
         address _liquidityLayerRouter
-    ) public initializer {
-        // Transfer ownership of the contract to deployer
+    ) external initializer {
+        __Ownable_init();
         _transferOwnership(_owner);
 
         tokenMessenger = ITokenMessenger(_tokenMessenger);
@@ -96,11 +99,7 @@ contract CircleBridgeAdapter is ILiquidityLayerAdapter, Router {
         uint32 _circleDomain = hyperlaneDomainToCircleDomain[
             _destinationDomain
         ];
-        bytes32 _remoteRouter = routers(_destinationDomain);
-        require(
-            _remoteRouter != bytes32(0),
-            "CircleBridgeAdapter: No router for domain"
-        );
+        bytes32 _remoteRouter = _mustHaveRemoteRouter(_destinationDomain);
 
         // Approve the token to Circle. We assume that the LiquidityLayerRouter
         // has already transferred the token to this contract.
@@ -127,6 +126,7 @@ contract CircleBridgeAdapter is ILiquidityLayerAdapter, Router {
         uint256 _amount,
         bytes calldata _adapterData // The adapter data from the message
     ) external onlyLiquidityLayerRouter returns (address, uint256) {
+        _mustHaveRemoteRouter(_originDomain);
         // The origin Circle domain
         uint32 _originCircleDomain = hyperlaneDomainToCircleDomain[
             _originDomain
@@ -151,10 +151,9 @@ contract CircleBridgeAdapter is ILiquidityLayerAdapter, Router {
         );
 
         // Transfer the token out to the recipient
-        // TODO: use safeTransfer
         // Circle doesn't charge any fee, so we can safely transfer out the
         // exact amount that was bridged over.
-        require(_token.transfer(_recipient, _amount), "!transfer out");
+        _token.safeTransfer(_recipient, _amount);
 
         return (address(_token), _amount);
     }

package/contracts/middleware/liquidity-layer/adapters/PortalAdapter.sol

@@ -21,7 +21,7 @@ contract PortalAdapter is ILiquidityLayerAdapter, Router {
     /// @notice transferId => token address
     mapping(bytes32 => address) public portalTransfersProcessed;
 
-    uint32 localDomain;
+    uint32 public localDomain;
 
     // We could technically use Portal's sequence number here but it doesn't
     // get passed through, so we would have to parse the VAA twice

package/contracts/mock/MockHyperlaneEnvironment.sol

@@ -33,6 +33,9 @@ contract MockHyperlaneEnvironment {
         isms[originDomain] = new TestIsm();
         isms[destinationDomain] = new TestIsm();
 
+        originMailbox.setDefaultIsm(isms[originDomain]);
+        destinationMailbox.setDefaultIsm(isms[destinationDomain]);
+
         mailboxes[_originDomain] = originMailbox;
         mailboxes[_destinationDomain] = destinationMailbox;