@hyperlane-xyz/core 1.0.0-beta8 → 1.0.0

package/contracts/InterchainGasPaymaster.sol

@@ -53,15 +53,44 @@ 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}("");
+            // TODO reconsider this?
+            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/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)

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

@@ -3,15 +3,15 @@ pragma solidity ^0.8.13;
 
 import {Router} from "../../../Router.sol";
 
-import {ICircleBridge} from "../interfaces/circle/ICircleBridge.sol";
+import {ITokenMessenger} from "../interfaces/circle/ITokenMessenger.sol";
 import {ICircleMessageTransmitter} from "../interfaces/circle/ICircleMessageTransmitter.sol";
 import {ILiquidityLayerAdapter} from "../interfaces/ILiquidityLayerAdapter.sol";
 
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 
 contract CircleBridgeAdapter is ILiquidityLayerAdapter, Router {
-    /// @notice The CircleBridge contract.
-    ICircleBridge public circleBridge;
+    /// @notice The TokenMessenger contract.
+    ITokenMessenger public tokenMessenger;
 
     /// @notice The Circle MessageTransmitter contract.
     ICircleMessageTransmitter public circleMessageTransmitter;
@@ -61,20 +61,20 @@ contract CircleBridgeAdapter is ILiquidityLayerAdapter, Router {
 
     /**
      * @param _owner The new owner.
-     * @param _circleBridge The CircleBridge contract.
+     * @param _tokenMessenger The TokenMessenger contract.
      * @param _circleMessageTransmitter The Circle MessageTransmitter contract.
      * @param _liquidityLayerRouter The LiquidityLayerRouter contract.
      */
     function initialize(
         address _owner,
-        address _circleBridge,
+        address _tokenMessenger,
         address _circleMessageTransmitter,
         address _liquidityLayerRouter
     ) public initializer {
         // Transfer ownership of the contract to deployer
         _transferOwnership(_owner);
 
-        circleBridge = ICircleBridge(_circleBridge);
+        tokenMessenger = ITokenMessenger(_tokenMessenger);
         circleMessageTransmitter = ICircleMessageTransmitter(
             _circleMessageTransmitter
         );
@@ -105,11 +105,11 @@ contract CircleBridgeAdapter is ILiquidityLayerAdapter, Router {
         // Approve the token to Circle. We assume that the LiquidityLayerRouter
         // has already transferred the token to this contract.
         require(
-            IERC20(_token).approve(address(circleBridge), _amount),
+            IERC20(_token).approve(address(tokenMessenger), _amount),
             "!approval"
         );
 
-        uint64 _nonce = circleBridge.depositForBurn(
+        uint64 _nonce = tokenMessenger.depositForBurn(
             _amount,
             _circleDomain,
             _remoteRouter, // Mint to the remote router
@@ -236,8 +236,6 @@ contract CircleBridgeAdapter is ILiquidityLayerAdapter, Router {
         pure
         returns (bytes32)
     {
-        // The hash is of a uint256 nonce, not a uint64 one.
-        return
-            keccak256(abi.encodePacked(_originCircleDomain, uint256(_nonce)));
+        return keccak256(abi.encodePacked(_originCircleDomain, _nonce));
     }
 }

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

@@ -0,0 +1,216 @@
+// 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/circle/{ICircleBridge.sol → ITokenMessenger.sol}

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.13;
 
-interface ICircleBridge {
+interface ITokenMessenger {
     event MessageSent(bytes message);
 
     /**
@@ -9,7 +9,7 @@ interface ICircleBridge {
      * Emits a `DepositForBurn` event.
      * @dev reverts if:
      * - given burnToken is not supported
-     * - given destinationDomain has no CircleBridge registered
+     * - given destinationDomain has no TokenMessenger registered
      * - transferFrom() reverts. For example, if sender's burnToken balance or approved allowance
      * to this contract is less than `amount`.
      * - burn() reverts. For example, if `amount` is 0.
@@ -37,7 +37,7 @@ interface ICircleBridge {
      * @dev reverts if:
      * - given destinationCaller is zero address
      * - given burnToken is not supported
-     * - given destinationDomain has no CircleBridge registered
+     * - given destinationDomain has no TokenMessenger registered
      * - transferFrom() reverts. For example, if sender's burnToken balance or approved allowance
      * to this contract is less than `amount`.
      * - burn() reverts. For example, if `amount` is 0.

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);
+}

package/contracts/mock/MockCircleMessageTransmitter.sol

@@ -20,7 +20,7 @@ contract MockCircleMessageTransmitter is ICircleMessageTransmitter {
         success = true;
     }
 
-    function hashSourceAndNonce(uint32 _source, uint256 _nonce)
+    function hashSourceAndNonce(uint32 _source, uint64 _nonce)
         public
         pure
         returns (bytes32)

package/contracts/mock/{MockCircleBridge.sol → MockCircleTokenMessenger.sol}

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.13;
 
-import {ICircleBridge} from "../middleware/liquidity-layer/interfaces/circle/ICircleBridge.sol";
+import {ITokenMessenger} from "../middleware/liquidity-layer/interfaces/circle/ITokenMessenger.sol";
 import {MockToken} from "./MockToken.sol";
 
-contract MockCircleBridge is ICircleBridge {
+contract MockCircleTokenMessenger is ITokenMessenger {
     uint64 public nextNonce = 0;
     MockToken token;
 

package/contracts/mock/MockPortalBridge.sol

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.13;
+
+import {IPortalTokenBridge} from "../middleware/liquidity-layer/interfaces/portal/IPortalTokenBridge.sol";
+import {MockToken} from "./MockToken.sol";
+import {TypeCasts} from "../libs/TypeCasts.sol";
+
+contract MockPortalBridge is IPortalTokenBridge {
+    uint256 nextNonce = 0;
+    MockToken token;
+
+    constructor(MockToken _token) {
+        token = _token;
+    }
+
+    function transferTokensWithPayload(
+        address,
+        uint256 amount,
+        uint16,
+        bytes32,
+        uint32,
+        bytes memory
+    ) external payable returns (uint64 sequence) {
+        nextNonce = nextNonce + 1;
+        token.transferFrom(msg.sender, address(this), amount);
+        token.burn(amount);
+        return uint64(nextNonce);
+    }
+
+    function wrappedAsset(uint16, bytes32) external view returns (address) {
+        return address(token);
+    }
+
+    function isWrappedAsset(address) external pure returns (bool) {
+        return true;
+    }
+
+    function completeTransferWithPayload(bytes memory encodedVm)
+        external
+        returns (bytes memory)
+    {
+        (uint32 _originDomain, uint224 _nonce, uint256 _amount) = abi.decode(
+            encodedVm,
+            (uint32, uint224, uint256)
+        );
+
+        token.mint(msg.sender, _amount);
+        // Format it so that parseTransferWithPayload returns the desired payload
+        return
+            abi.encode(
+                TypeCasts.addressToBytes32(address(token)),
+                adapterData(_originDomain, _nonce, address(token))
+            );
+    }
+
+    function parseTransferWithPayload(bytes memory encoded)
+        external
+        pure
+        returns (TransferWithPayload memory transfer)
+    {
+        (bytes32 tokenAddress, bytes memory payload) = abi.decode(
+            encoded,
+            (bytes32, bytes)
+        );
+        transfer.payload = payload;
+        transfer.tokenAddress = tokenAddress;
+    }
+
+    function adapterData(
+        uint32 _originDomain,
+        uint224 _nonce,
+        address _token
+    ) public pure returns (bytes memory) {
+        return
+            abi.encode(
+                _originDomain,
+                _nonce,
+                TypeCasts.addressToBytes32(_token)
+            );
+    }
+
+    function mockPortalVaa(
+        uint32 _originDomain,
+        uint224 _nonce,
+        uint256 _amount
+    ) public pure returns (bytes memory) {
+        return abi.encode(_originDomain, _nonce, _amount);
+    }
+}