@hyperlane-xyz/core 0.5.4-3 → 0.5.6

package/contracts/libs/Message.sol

@@ -4,35 +4,24 @@ pragma solidity >=0.8.0;
 import {TypeCasts} from "./TypeCasts.sol";
 
 /**
- * @title Hyperlane Message Library
- * @notice Library for formatted messages used by Mailbox
+ * @title Message Library
+ * @author Celo Labs Inc.
+ * @notice Library for formatted messages used by Outbox and Replica.
  **/
 library Message {
     using TypeCasts for bytes32;
 
-    uint256 private constant VERSION_OFFSET = 0;
-    uint256 private constant NONCE_OFFSET = 1;
-    uint256 private constant ORIGIN_OFFSET = 5;
-    uint256 private constant SENDER_OFFSET = 9;
-    uint256 private constant DESTINATION_OFFSET = 41;
-    uint256 private constant RECIPIENT_OFFSET = 45;
-    uint256 private constant BODY_OFFSET = 77;
-
     /**
-     * @notice Returns formatted (packed) Hyperlane message with provided fields
+     * @notice Returns formatted (packed) message with provided fields
      * @dev This function should only be used in memory message construction.
-     * @param _version The version of the origin and destination Mailboxes
-     * @param _nonce A nonce to uniquely identify the message on its origin chain
-     * @param _originDomain Domain of origin chain
+     * @param _originDomain Domain of home chain
      * @param _sender Address of sender as bytes32
      * @param _destinationDomain Domain of destination chain
      * @param _recipient Address of recipient on destination chain as bytes32
      * @param _messageBody Raw bytes of message body
      * @return Formatted message
-     */
+     **/
     function formatMessage(
-        uint8 _version,
-        uint32 _nonce,
         uint32 _originDomain,
         bytes32 _sender,
         uint32 _destinationDomain,
@@ -41,8 +30,6 @@ library Message {
     ) internal pure returns (bytes memory) {
         return
             abi.encodePacked(
-                _version,
-                _nonce,
                 _originDomain,
                 _sender,
                 _destinationDomain,
@@ -52,112 +39,84 @@ library Message {
     }
 
     /**
-     * @notice Returns the message ID.
-     * @param _message ABI encoded Hyperlane message.
-     * @return ID of `_message`
-     */
-    function id(bytes memory _message) internal pure returns (bytes32) {
-        return keccak256(_message);
-    }
-
-    /**
-     * @notice Returns the message version.
-     * @param _message ABI encoded Hyperlane message.
-     * @return Version of `_message`
-     */
-    function version(bytes calldata _message) internal pure returns (uint8) {
-        return uint8(bytes1(_message[VERSION_OFFSET:NONCE_OFFSET]));
-    }
-
-    /**
-     * @notice Returns the message nonce.
-     * @param _message ABI encoded Hyperlane message.
-     * @return Nonce of `_message`
-     */
-    function nonce(bytes calldata _message) internal pure returns (uint32) {
-        return uint32(bytes4(_message[NONCE_OFFSET:ORIGIN_OFFSET]));
-    }
-
-    /**
-     * @notice Returns the message origin domain.
-     * @param _message ABI encoded Hyperlane message.
-     * @return Origin domain of `_message`
-     */
-    function origin(bytes calldata _message) internal pure returns (uint32) {
-        return uint32(bytes4(_message[ORIGIN_OFFSET:SENDER_OFFSET]));
-    }
-
-    /**
-     * @notice Returns the message sender as bytes32.
-     * @param _message ABI encoded Hyperlane message.
-     * @return Sender of `_message` as bytes32
-     */
-    function sender(bytes calldata _message) internal pure returns (bytes32) {
-        return bytes32(_message[SENDER_OFFSET:DESTINATION_OFFSET]);
-    }
-
-    /**
-     * @notice Returns the message sender as address.
-     * @param _message ABI encoded Hyperlane message.
-     * @return Sender of `_message` as address
-     */
-    function senderAddress(bytes calldata _message)
-        internal
-        pure
-        returns (address)
-    {
-        return sender(_message).bytes32ToAddress();
-    }
-
-    /**
-     * @notice Returns the message destination domain.
-     * @param _message ABI encoded Hyperlane message.
-     * @return Destination domain of `_message`
-     */
-    function destination(bytes calldata _message)
-        internal
-        pure
-        returns (uint32)
-    {
-        return uint32(bytes4(_message[DESTINATION_OFFSET:RECIPIENT_OFFSET]));
-    }
-
-    /**
-     * @notice Returns the message recipient as bytes32.
-     * @param _message ABI encoded Hyperlane message.
-     * @return Recipient of `_message` as bytes32
+     * @notice Returns leaf of formatted message with provided fields.
+     * @dev hash of abi packed message and leaf index.
+     * @param _message Raw bytes of message contents.
+     * @param _leafIndex Index of the message in the tree
+     * @return Leaf (hash) of formatted message
      */
-    function recipient(bytes calldata _message)
+    function leaf(bytes calldata _message, uint256 _leafIndex)
         internal
         pure
         returns (bytes32)
     {
-        return bytes32(_message[RECIPIENT_OFFSET:BODY_OFFSET]);
+        return keccak256(abi.encodePacked(_message, _leafIndex));
     }
 
     /**
-     * @notice Returns the message recipient as address.
-     * @param _message ABI encoded Hyperlane message.
-     * @return Recipient of `_message` as address
+     * @notice Decode raw message bytes into structured message fields.
+     * @dev Efficiently slices calldata into structured message fields.
+     * @param _message Raw bytes of message contents.
+     * @return origin Domain of home chain
+     * @return sender Address of sender as bytes32
+     * @return destination Domain of destination chain
+     * @return recipient Address of recipient on destination chain as bytes32
+     * @return body Raw bytes of message body
      */
-    function recipientAddress(bytes calldata _message)
+    function destructure(bytes calldata _message)
         internal
         pure
-        returns (address)
+        returns (
+            uint32 origin,
+            bytes32 sender,
+            uint32 destination,
+            bytes32 recipient,
+            bytes calldata body
+        )
     {
-        return recipient(_message).bytes32ToAddress();
+        return (
+            uint32(bytes4(_message[0:4])),
+            bytes32(_message[4:36]),
+            uint32(bytes4(_message[36:40])),
+            bytes32(_message[40:72]),
+            bytes(_message[72:])
+        );
     }
 
     /**
-     * @notice Returns the message body.
-     * @param _message ABI encoded Hyperlane message.
-     * @return Body of `_message`
+     * @notice Decode raw message bytes into structured message fields.
+     * @dev Efficiently slices calldata into structured message fields.
+     * @param _message Raw bytes of message contents.
+     * @return origin Domain of home chain
+     * @return sender Address of sender as address (bytes20)
+     * @return destination Domain of destination chain
+     * @return recipient Address of recipient on destination chain as address (bytes20)
+     * @return body Raw bytes of message body
      */
-    function body(bytes calldata _message)
+    function destructureAddresses(bytes calldata _message)
         internal
         pure
-        returns (bytes calldata)
+        returns (
+            uint32,
+            address,
+            uint32,
+            address,
+            bytes calldata
+        )
     {
-        return bytes(_message[BODY_OFFSET:]);
+        (
+            uint32 _origin,
+            bytes32 _sender,
+            uint32 destination,
+            bytes32 _recipient,
+            bytes calldata body
+        ) = destructure(_message);
+        return (
+            _origin,
+            _sender.bytes32ToAddress(),
+            destination,
+            _recipient.bytes32ToAddress(),
+            body
+        );
     }
 }

package/contracts/middleware/InterchainAccountRouter.sol

@@ -1,12 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.13;
 
-// ============ Internal Imports ============
 import {OwnableMulticall, Call} from "../OwnableMulticall.sol";
-import {Router} from "../Router.sol";
 import {IInterchainAccountRouter} from "../../interfaces/IInterchainAccountRouter.sol";
 
 // ============ External Imports ============
+import {Router} from "../Router.sol";
 import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
 import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
@@ -27,24 +26,34 @@ contract InterchainAccountRouter is Router, IInterchainAccountRouter {
 
     function initialize(
         address _owner,
-        address _mailbox,
+        address _abacusConnectionManager,
         address _interchainGasPaymaster
     ) public initializer {
         // Transfer ownership of the contract to deployer
         _transferOwnership(_owner);
-        // Set the addresses for the Mailbox and IGP
+        // Set the addresses for the ACM and IGP
         // Alternatively, this could be done later in an initialize method
-        _setMailbox(_mailbox);
+        _setAbacusConnectionManager(_abacusConnectionManager);
         _setInterchainGasPaymaster(_interchainGasPaymaster);
     }
 
     function dispatch(uint32 _destinationDomain, Call[] calldata calls)
         external
-        returns (bytes32)
+        returns (uint256)
     {
         return _dispatch(_destinationDomain, abi.encode(msg.sender, calls));
     }
 
+    function dispatch(
+        uint32 _destinationDomain,
+        address target,
+        bytes calldata data
+    ) external returns (uint256) {
+        Call[] memory calls = new Call[](1);
+        calls[0] = Call({to: target, data: data});
+        return _dispatch(_destinationDomain, abi.encode(msg.sender, calls));
+    }
+
     function getInterchainAccount(uint32 _origin, address _sender)
         public
         view

package/contracts/middleware/InterchainQueryRouter.sol

@@ -1,12 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.13;
 
-// ============ Internal Imports ============
 import {OwnableMulticall, Call} from "../OwnableMulticall.sol";
-import {Router} from "../Router.sol";
 import {IInterchainQueryRouter} from "../../interfaces/IInterchainQueryRouter.sol";
 
 // ============ External Imports ============
+import {Router} from "../Router.sol";
 import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
 import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
@@ -33,17 +32,37 @@ contract InterchainQueryRouter is
 
     function initialize(
         address _owner,
-        address _mailbox,
+        address _abacusConnectionManager,
         address _interchainGasPaymaster
     ) public initializer {
         // Transfer ownership of the contract to deployer
         _transferOwnership(_owner);
-        // Set the addresses for the Mailbox and IGP
+        // Set the addresses for the ACM and IGP
         // Alternatively, this could be done later in an initialize method
-        _setMailbox(_mailbox);
+        _setAbacusConnectionManager(_abacusConnectionManager);
         _setInterchainGasPaymaster(_interchainGasPaymaster);
     }
 
+    /**
+     * @param _destinationDomain Domain of destination chain
+     * @param target The address of the contract to query on destination chain.
+     * @param queryData The calldata of the view call to make on the destination chain.
+     * @param callback Callback function selector on `msg.sender` and optionally abi-encoded prefix arguments.
+     */
+    function query(
+        uint32 _destinationDomain,
+        address target,
+        bytes calldata queryData,
+        bytes calldata callback
+    ) external returns (uint256 leafIndex) {
+        // TODO: fix this ugly arrayification
+        Call[] memory calls = new Call[](1);
+        calls[0] = Call({to: target, data: queryData});
+        bytes[] memory callbacks = new bytes[](1);
+        callbacks[0] = callback;
+        leafIndex = query(_destinationDomain, calls, callbacks);
+    }
+
     /**
      * @param _destinationDomain Domain of destination chain
      * @param call Call (to and data packed struct) to be made on destination chain.
@@ -53,13 +72,13 @@ contract InterchainQueryRouter is
         uint32 _destinationDomain,
         Call calldata call,
         bytes calldata callback
-    ) external returns (bytes32 messageId) {
+    ) external returns (uint256 leafIndex) {
         // TODO: fix this ugly arrayification
         Call[] memory calls = new Call[](1);
         calls[0] = call;
         bytes[] memory callbacks = new bytes[](1);
         callbacks[0] = callback;
-        messageId = query(_destinationDomain, calls, callbacks);
+        leafIndex = query(_destinationDomain, calls, callbacks);
     }
 
     /**
@@ -71,12 +90,12 @@ contract InterchainQueryRouter is
         uint32 _destinationDomain,
         Call[] memory calls,
         bytes[] memory callbacks
-    ) public returns (bytes32 messageId) {
+    ) public returns (uint256 leafIndex) {
         require(
             calls.length == callbacks.length,
             "InterchainQueryRouter: calls and callbacks must be same length"
         );
-        messageId = _dispatch(
+        leafIndex = _dispatch(
             _destinationDomain,
             abi.encode(Action.DISPATCH, msg.sender, calls, callbacks)
         );

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

@@ -21,13 +21,14 @@ contract LiquidityLayerRouter is Router {
 
     function initialize(
         address _owner,
-        address _mailbox,
+        address _abacusConnectionManager,
         address _interchainGasPaymaster
     ) public initializer {
         // Transfer ownership of the contract to deployer
         _transferOwnership(_owner);
+        // Set the addresses for the ACM and IGP
         // Alternatively, this could be done later in an initialize method
-        _setMailbox(_mailbox);
+        _setAbacusConnectionManager(_abacusConnectionManager);
         _setInterchainGasPaymaster(_interchainGasPaymaster);
     }
 

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

@@ -74,7 +74,8 @@ contract CircleBridgeAdapter is ILiquidityLayerAdapter, Router {
         // Transfer ownership of the contract to deployer
         _transferOwnership(_owner);
 
-        // Set the addresses for the IGP to address(0) - it's not used.
+        // Set the addresses for the ACM and IGP to address(0) - they aren't used.
+        _setAbacusConnectionManager(address(0));
         _setInterchainGasPaymaster(address(0));
 
         circleBridge = ICircleBridge(_circleBridge);

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

@@ -0,0 +1,215 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.13;
+
+import {Router} from "../../../Router.sol";
+
+import {IPortalTokenBridge} from "../interfaces/portal/IPortalTokenBridge.sol";
+import {ILiquidityLayerAdapter} from "../interfaces/ILiquidityLayerAdapter.sol";
+import {TypeCasts} from "../../../libs/TypeCasts.sol";
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+contract PortalAdapter is ILiquidityLayerAdapter, Router {
+    /// @notice The Portal TokenBridge contract.
+    IPortalTokenBridge public portalTokenBridge;
+
+    /// @notice The LiquidityLayerRouter contract.
+    address public liquidityLayerRouter;
+
+    /// @notice Hyperlane domain => Wormhole domain.
+    mapping(uint32 => uint16) public hyperlaneDomainToWormholeDomain;
+    /// @notice transferId => token address
+    mapping(bytes32 => address) public portalTransfersProcessed;
+
+    uint32 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
+    // 224 bits should be large enough and allows us to pack into a single slot
+    // with a Hyperlane domain
+    uint224 public nonce = 0;
+
+    /**
+     * @notice Emits the nonce of the Portal message when a token is bridged.
+     * @param nonce The nonce of the Portal message.
+     * @param portalSequence The sequence of the Portal message.
+     * @param destination The hyperlane domain of the destination
+     */
+    event BridgedToken(
+        uint256 nonce,
+        uint64 portalSequence,
+        uint32 destination
+    );
+
+    /**
+     * @notice Emitted when the Hyperlane domain to Wormhole domain mapping is updated.
+     * @param hyperlaneDomain The Hyperlane domain.
+     * @param wormholeDomain The Wormhole domain.
+     */
+    event DomainAdded(uint32 indexed hyperlaneDomain, uint32 wormholeDomain);
+
+    modifier onlyLiquidityLayerRouter() {
+        require(msg.sender == liquidityLayerRouter, "!liquidityLayerRouter");
+        _;
+    }
+
+    /**
+     * @param _localDomain The local hyperlane domain
+     * @param _owner The new owner.
+     * @param _portalTokenBridge The Portal TokenBridge contract.
+     * @param _liquidityLayerRouter The LiquidityLayerRouter contract.
+     */
+    function initialize(
+        uint32 _localDomain,
+        address _owner,
+        address _portalTokenBridge,
+        address _liquidityLayerRouter
+    ) public initializer {
+        // Transfer ownership of the contract to deployer
+        _transferOwnership(_owner);
+
+        localDomain = _localDomain;
+        portalTokenBridge = IPortalTokenBridge(_portalTokenBridge);
+        liquidityLayerRouter = _liquidityLayerRouter;
+    }
+
+    /**
+     * Sends tokens as requested by the router
+     * @param _destinationDomain The hyperlane domain of the destination
+     * @param _token The token address
+     * @param _amount The amount of tokens to send
+     */
+    function sendTokens(
+        uint32 _destinationDomain,
+        bytes32, // _recipientAddress, unused
+        address _token,
+        uint256 _amount
+    ) external onlyLiquidityLayerRouter returns (bytes memory) {
+        nonce = nonce + 1;
+        uint16 _wormholeDomain = hyperlaneDomainToWormholeDomain[
+            _destinationDomain
+        ];
+
+        bytes32 _remoteRouter = _mustHaveRemoteRouter(_destinationDomain);
+
+        // Approve the token to Portal. We assume that the LiquidityLayerRouter
+        // has already transferred the token to this contract.
+        require(
+            IERC20(_token).approve(address(portalTokenBridge), _amount),
+            "!approval"
+        );
+
+        uint64 portalSequence = portalTokenBridge.transferTokensWithPayload(
+            _token,
+            _amount,
+            _wormholeDomain,
+            _remoteRouter,
+            // Nonce for grouping Portal messages in the same tx, not relevant for us
+            // https://book.wormhole.com/technical/evm/coreLayer.html#emitting-a-vaa
+            0,
+            // Portal Payload used in completeTransfer
+            abi.encode(localDomain, nonce)
+        );
+
+        emit BridgedToken(nonce, portalSequence, _destinationDomain);
+        return abi.encode(nonce);
+    }
+
+    /**
+     * Sends the tokens to the recipient as requested by the router
+     * @param _originDomain The hyperlane domain of the origin
+     * @param _recipient The address of the recipient
+     * @param _amount The amount of tokens to send
+     * @param _adapterData The adapter data from the origin chain, containing the nonce
+     */
+    function receiveTokens(
+        uint32 _originDomain, // Hyperlane domain
+        address _recipient,
+        uint256 _amount,
+        bytes calldata _adapterData // The adapter data from the message
+    ) external onlyLiquidityLayerRouter returns (address, uint256) {
+        // Get the nonce information from the adapterData
+        uint224 _nonce = abi.decode(_adapterData, (uint224));
+
+        address _tokenAddress = portalTransfersProcessed[
+            transferId(_originDomain, _nonce)
+        ];
+
+        require(
+            _tokenAddress != address(0x0),
+            "Portal Transfer has not yet been completed"
+        );
+
+        IERC20 _token = IERC20(_tokenAddress);
+
+        // Transfer the token out to the recipient
+        // TODO: use safeTransfer
+        // Portal 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");
+        return (_tokenAddress, _amount);
+    }
+
+    /**
+     * Completes the Portal transfer which sends the funds to this adapter.
+     * The router can call receiveTokens to move those funds to the ultimate recipient.
+     * @param encodedVm The VAA from the Wormhole Guardians
+     */
+    function completeTransfer(bytes memory encodedVm) public {
+        bytes memory _tokenBridgeTransferWithPayload = portalTokenBridge
+            .completeTransferWithPayload(encodedVm);
+        IPortalTokenBridge.TransferWithPayload
+            memory _transfer = portalTokenBridge.parseTransferWithPayload(
+                _tokenBridgeTransferWithPayload
+            );
+
+        (uint32 _originDomain, uint224 _nonce) = abi.decode(
+            _transfer.payload,
+            (uint32, uint224)
+        );
+
+        // Logic taken from here https://github.com/wormhole-foundation/wormhole/blob/dev.v2/ethereum/contracts/bridge/Bridge.sol#L503
+        address tokenAddress = _transfer.tokenChain ==
+            hyperlaneDomainToWormholeDomain[localDomain]
+            ? TypeCasts.bytes32ToAddress(_transfer.tokenAddress)
+            : portalTokenBridge.wrappedAsset(
+                _transfer.tokenChain,
+                _transfer.tokenAddress
+            );
+
+        portalTransfersProcessed[
+            transferId(_originDomain, _nonce)
+        ] = tokenAddress;
+    }
+
+    // This contract is only a Router to be aware of remote router addresses,
+    // and doesn't actually send/handle Hyperlane messages directly
+    function _handle(
+        uint32, // origin
+        bytes32, // sender
+        bytes calldata // message
+    ) internal pure override {
+        revert("No messages expected");
+    }
+
+    function addDomain(uint32 _hyperlaneDomain, uint16 _wormholeDomain)
+        external
+        onlyOwner
+    {
+        hyperlaneDomainToWormholeDomain[_hyperlaneDomain] = _wormholeDomain;
+
+        emit DomainAdded(_hyperlaneDomain, _wormholeDomain);
+    }
+
+    /**
+     * The key that is used to track fulfilled Portal transfers
+     * @param _hyperlaneDomain The hyperlane of the origin
+     * @param _nonce The nonce of the adapter on the origin
+     */
+    function transferId(uint32 _hyperlaneDomain, uint224 _nonce)
+        public
+        pure
+        returns (bytes32)
+    {
+        return bytes32(abi.encodePacked(_hyperlaneDomain, _nonce));
+    }
+}

package/contracts/middleware/liquidity-layer/interfaces/portal/IPortalTokenBridge.sol

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.13;
+
+// Portal's interface from their docs
+interface IPortalTokenBridge {
+    struct Transfer {
+        uint8 payloadID;
+        uint256 amount;
+        bytes32 tokenAddress;
+        uint16 tokenChain;
+        bytes32 to;
+        uint16 toChain;
+        uint256 fee;
+    }
+
+    struct TransferWithPayload {
+        uint8 payloadID;
+        uint256 amount;
+        bytes32 tokenAddress;
+        uint16 tokenChain;
+        bytes32 to;
+        uint16 toChain;
+        bytes32 fromAddress;
+        bytes payload;
+    }
+
+    struct AssetMeta {
+        uint8 payloadID;
+        bytes32 tokenAddress;
+        uint16 tokenChain;
+        uint8 decimals;
+        bytes32 symbol;
+        bytes32 name;
+    }
+
+    struct RegisterChain {
+        bytes32 module;
+        uint8 action;
+        uint16 chainId;
+        uint16 emitterChainID;
+        bytes32 emitterAddress;
+    }
+
+    struct UpgradeContract {
+        bytes32 module;
+        uint8 action;
+        uint16 chainId;
+        bytes32 newContract;
+    }
+
+    struct RecoverChainId {
+        bytes32 module;
+        uint8 action;
+        uint256 evmChainId;
+        uint16 newChainId;
+    }
+
+    event ContractUpgraded(
+        address indexed oldContract,
+        address indexed newContract
+    );
+
+    function transferTokensWithPayload(
+        address token,
+        uint256 amount,
+        uint16 recipientChain,
+        bytes32 recipient,
+        uint32 nonce,
+        bytes memory payload
+    ) external payable returns (uint64 sequence);
+
+    function completeTransferWithPayload(bytes memory encodedVm)
+        external
+        returns (bytes memory);
+
+    function parseTransferWithPayload(bytes memory encoded)
+        external
+        pure
+        returns (TransferWithPayload memory transfer);
+
+    function wrappedAsset(uint16 tokenChainId, bytes32 tokenAddress)
+        external
+        view
+        returns (address);
+
+    function isWrappedAsset(address token) external view returns (bool);
+}