@hyperlane-xyz/core 1.0.0-beta8 → 1.0.1-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.
@@ -53,15 +54,43 @@ contract InterchainGasPaymaster is IInterchainGasPaymaster, OwnableUpgradeable {
         uint256 _gasAmount,
         address _refundAddress
     ) external payable override {
-        // Silence compiler warning. The NatSpec @param requires the parameter to be named.
-        // While not used at the moment, future versions of the paymaster have behavior specific
-        // to the destination domain and refund overpayments to the _refundAddress.
-        _destinationDomain;
-        _refundAddress;
+        uint256 _requiredPayment = quoteGasPayment(
+            _destinationDomain,
+            _gasAmount
+        );
+        require(
+            msg.value >= _requiredPayment,
+            "insufficient interchain gas payment"
+        );
+        uint256 _overpayment = msg.value - _requiredPayment;
+        if (_overpayment > 0) {
+            (bool _success, ) = _refundAddress.call{value: _overpayment}("");
+            require(_success, "Interchain gas payment refund failed");
+        }
 
         emit GasPayment(_messageId, _gasAmount, msg.value);
     }
 
+    /**
+     * @notice Quotes the amount of native tokens to pay for interchain gas.
+     * @param _destinationDomain The domain of the message's destination chain.
+     * @param _gasAmount The amount of destination gas to pay for. Currently unused.
+     * @return The amount of native tokens required to pay for interchain gas.
+     */
+    function quoteGasPayment(uint32 _destinationDomain, uint256 _gasAmount)
+        public
+        pure
+        override
+        returns (uint256)
+    {
+        // Silence compiler warning.
+        _destinationDomain;
+        _gasAmount;
+        // Charge a flat 1 wei fee.
+        // This is an intermediate step toward fully on-chain accurate gas payment quoting.
+        return 1;
+    }
+
     /**
      * @notice Transfers the entire native token balance to the owner of the contract.
      * @dev The owner must be able to receive native tokens.

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/middleware/liquidity-layer/LiquidityLayerRouter.sol

@@ -4,7 +4,6 @@ pragma solidity ^0.8.13;
 import {Router} from "../../Router.sol";
 
 import {ILiquidityLayerRouter} from "../../../interfaces/ILiquidityLayerRouter.sol";
-import {ICircleBridge} from "./interfaces/circle/ICircleBridge.sol";
 import {ICircleMessageTransmitter} from "./interfaces/circle/ICircleMessageTransmitter.sol";
 import {ILiquidityLayerAdapter} from "./interfaces/ILiquidityLayerAdapter.sol";
 import {ILiquidityLayerMessageRecipient} from "../../../interfaces/ILiquidityLayerMessageRecipient.sol";
@@ -43,11 +42,11 @@ contract LiquidityLayerRouter is Router, ILiquidityLayerRouter {
     function dispatchWithTokens(
         uint32 _destinationDomain,
         bytes32 _recipientAddress,
-        bytes calldata _messageBody,
         address _token,
         uint256 _amount,
-        string calldata _bridge
-    ) external payable returns (bytes32) {
+        string calldata _bridge,
+        bytes calldata _messageBody
+    ) external returns (bytes32) {
         ILiquidityLayerAdapter _adapter = _getAdapter(_bridge);
 
         // Transfer the tokens to the adapter
@@ -79,14 +78,7 @@ contract LiquidityLayerRouter is Router, ILiquidityLayerRouter {
         );
 
         // Dispatch the _messageWithMetadata to the destination's LiquidityLayerRouter.
-        return
-            _dispatchWithGas(
-                _destinationDomain,
-                _messageWithMetadata,
-                0, // TODO eventually accommodate gas amounts
-                msg.value,
-                msg.sender
-            );
+        return _dispatch(_destinationDomain, _messageWithMetadata);
     }
 
     // Handles a message from an enrolled remote LiquidityLayerRouter
@@ -121,13 +113,15 @@ contract LiquidityLayerRouter is Router, ILiquidityLayerRouter {
                 _adapterData
             );
 
-        _userRecipient.handleWithTokens(
-            _origin,
-            _originalSender,
-            _userMessageBody,
-            _token,
-            _receivedAmount
-        );
+        if (_userMessageBody.length > 0) {
+            _userRecipient.handleWithTokens(
+                _origin,
+                _originalSender,
+                _userMessageBody,
+                _token,
+                _receivedAmount
+            );
+        }
     }
 
     function setLiquidityLayerAdapter(string calldata _bridge, address _adapter)