@hyperlane-xyz/core 1.5.8 → 3.0.0-beta0

package/contracts/test/TestMailbox.sol

@@ -3,28 +3,15 @@ pragma solidity >=0.8.0;
 
 import {Mailbox} from "../Mailbox.sol";
 import {TypeCasts} from "../libs/TypeCasts.sol";
+import {Message} from "../libs/Message.sol";
 import {MerkleLib} from "../libs/Merkle.sol";
 import {IMessageRecipient} from "../interfaces/IMessageRecipient.sol";
 
 contract TestMailbox is Mailbox {
     using TypeCasts for bytes32;
 
-    constructor(uint32 _localDomain) Mailbox(_localDomain) {} // solhint-disable-line no-empty-blocks
-
-    function proof() external view returns (bytes32[32] memory) {
-        bytes32[32] memory _zeroes = MerkleLib.zeroHashes();
-        uint256 _index = tree.count - 1;
-        bytes32[32] memory _proof;
-
-        for (uint256 i = 0; i < 32; i++) {
-            uint256 _ithBit = (_index >> i) & 0x01;
-            if (_ithBit == 1) {
-                _proof[i] = tree.branch[i];
-            } else {
-                _proof[i] = _zeroes[i];
-            }
-        }
-        return _proof;
+    constructor(uint32 _localDomain) Mailbox(_localDomain) {
+        _transferOwnership(msg.sender);
     }
 
     function testHandle(
@@ -39,4 +26,34 @@ contract TestMailbox is Mailbox {
             _body
         );
     }
+
+    function buildOutboundMessage(
+        uint32 destinationDomain,
+        bytes32 recipientAddress,
+        bytes calldata body
+    ) external view returns (bytes memory) {
+        return _buildMessage(destinationDomain, recipientAddress, body);
+    }
+
+    function buildInboundMessage(
+        uint32 originDomain,
+        bytes32 recipientAddress,
+        bytes32 senderAddress,
+        bytes calldata body
+    ) external view returns (bytes memory) {
+        return
+            Message.formatMessage(
+                VERSION,
+                nonce,
+                originDomain,
+                senderAddress,
+                localDomain,
+                recipientAddress,
+                body
+            );
+    }
+
+    function updateLatestDispatchedId(bytes32 _id) external {
+        latestDispatchedId = _id;
+    }
 }

package/contracts/test/TestMerkleTreeHook.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {MerkleLib} from "../libs/Merkle.sol";
+import {MerkleTreeHook} from "../hooks/MerkleTreeHook.sol";
+
+contract TestMerkleTreeHook is MerkleTreeHook {
+    using MerkleLib for MerkleLib.Tree;
+
+    constructor(address _mailbox) MerkleTreeHook(_mailbox) {}
+
+    function proof() external view returns (bytes32[32] memory) {
+        bytes32[32] memory _zeroes = MerkleLib.zeroHashes();
+        uint256 _index = _tree.count - 1;
+        bytes32[32] memory _proof;
+
+        for (uint256 i = 0; i < 32; i++) {
+            uint256 _ithBit = (_index >> i) & 0x01;
+            if (_ithBit == 1) {
+                _proof[i] = _tree.branch[i];
+            } else {
+                _proof[i] = _zeroes[i];
+            }
+        }
+        return _proof;
+    }
+
+    function insert(bytes32 _id) external {
+        _tree.insert(_id);
+    }
+}

package/contracts/test/TestPostDispatchHook.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {IPostDispatchHook} from "../interfaces/hooks/IPostDispatchHook.sol";
+import {AbstractPostDispatchHook} from "../hooks/libs/AbstractPostDispatchHook.sol";
+
+contract TestPostDispatchHook is AbstractPostDispatchHook {
+    // ============ Public Storage ============
+
+    // test fees for quoteDispatch
+    uint256 public fee = 0;
+
+    // ============ External Functions ============
+
+    /// @inheritdoc IPostDispatchHook
+    function hookType() external pure override returns (uint8) {
+        return uint8(IPostDispatchHook.Types.UNUSED);
+    }
+
+    function supportsMetadata(bytes calldata)
+        public
+        pure
+        override
+        returns (bool)
+    {
+        return true;
+    }
+
+    function setFee(uint256 _fee) external {
+        fee = _fee;
+    }
+
+    // ============ Internal functions ============
+    function _postDispatch(
+        bytes calldata,
+        /*metadata*/
+        bytes calldata /*message*/
+    ) internal pure override {
+        // test - empty
+    }
+
+    function _quoteDispatch(
+        bytes calldata,
+        /*metadata*/
+        bytes calldata /*message*/
+    ) internal view override returns (uint256) {
+        return fee;
+    }
+}

package/contracts/test/TestQuery.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.8.13;
 
 import {InterchainQueryRouter} from "../middleware/InterchainQueryRouter.sol";
 import {TypeCasts} from "../libs/TypeCasts.sol";
-import {CallLib} from "../libs/Call.sol";
+import {CallLib} from "../middleware/libs/Call.sol";
 
 import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
 

package/contracts/test/TestQuerySender.sol

@@ -1,13 +1,11 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 pragma solidity >=0.8.0;
 
-import {IInterchainGasPaymaster} from "../interfaces/IInterchainGasPaymaster.sol";
-import {IInterchainQueryRouter} from "../interfaces/middleware/IInterchainQueryRouter.sol";
-import {CallLib} from "../libs/Call.sol";
+import {InterchainQueryRouter} from "../middleware/InterchainQueryRouter.sol";
+import {CallLib} from "../middleware/libs/Call.sol";
 
 contract TestQuerySender {
-    IInterchainQueryRouter queryRouter;
-    IInterchainGasPaymaster interchainGasPaymaster;
+    InterchainQueryRouter queryRouter;
 
     address public lastAddressResult;
     uint256 public lastUint256Result;
@@ -17,14 +15,8 @@ contract TestQuerySender {
     event ReceivedUint256Result(uint256 result);
     event ReceivedBytes32Result(bytes32 result);
 
-    function initialize(
-        address _queryRouterAddress,
-        address _interchainGasPaymaster
-    ) external {
-        queryRouter = IInterchainQueryRouter(_queryRouterAddress);
-        interchainGasPaymaster = IInterchainGasPaymaster(
-            _interchainGasPaymaster
-        );
+    function initialize(address _queryRouterAddress) external {
+        queryRouter = InterchainQueryRouter(_queryRouterAddress);
     }
 
     function queryAddress(
@@ -92,21 +84,13 @@ contract TestQuerySender {
         address _target,
         bytes calldata _targetData,
         bytes4 _callbackSelector,
-        uint256 _gasAmount
+        uint256 /*_gasAmount*/
     ) internal {
-        CallLib.StaticCallWithCallback[]
-            memory calls = new CallLib.StaticCallWithCallback[](1);
-        calls[0] = CallLib.build(
+        queryRouter.query(
+            _destinationDomain,
             _target,
             _targetData,
             abi.encodePacked(_callbackSelector)
         );
-        bytes32 _messageId = queryRouter.query(_destinationDomain, calls);
-        interchainGasPaymaster.payForGas{value: msg.value}(
-            _messageId,
-            _destinationDomain,
-            _gasAmount,
-            msg.sender
-        );
     }
 }

package/contracts/test/TestRecipient.sol

@@ -21,6 +21,7 @@ contract TestRecipient is
     event ReceivedMessage(
         uint32 indexed origin,
         bytes32 indexed sender,
+        uint256 indexed value,
         string message
     );
 
@@ -30,8 +31,8 @@ contract TestRecipient is
         uint32 _origin,
         bytes32 _sender,
         bytes calldata _data
-    ) external virtual override {
-        emit ReceivedMessage(_origin, _sender, string(_data));
+    ) external payable virtual override {
+        emit ReceivedMessage(_origin, _sender, msg.value, string(_data));
         lastSender = _sender;
         lastData = _data;
     }

package/contracts/test/TestRouter.sol

@@ -1,20 +1,18 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 pragma solidity >=0.6.11;
 
-import "../Router.sol";
+import "../client/Router.sol";
 
 contract TestRouter is Router {
     event InitializeOverload();
 
-    function initialize(address _mailbox, address _interchainGasPaymaster)
-        external
+    constructor(address _mailbox) Router(_mailbox) {}
+
+    function initialize(address _hook, address _interchainSecurityModule)
+        public
         initializer
     {
-        __HyperlaneConnectionClient_initialize(
-            _mailbox,
-            _interchainGasPaymaster
-        );
-        emit InitializeOverload();
+        _MailboxClient_initialize(_hook, _interchainSecurityModule, msg.sender);
     }
 
     function _handle(
@@ -39,23 +37,7 @@ contract TestRouter is Router {
         return _mustHaveRemoteRouter(_domain);
     }
 
-    function dispatch(uint32 _destination, bytes memory _msg) external {
+    function dispatch(uint32 _destination, bytes memory _msg) external payable {
         _dispatch(_destination, _msg);
     }
-
-    function dispatchWithGas(
-        uint32 _destinationDomain,
-        bytes memory _messageBody,
-        uint256 _gasAmount,
-        uint256 _gasPayment,
-        address _gasPaymentRefundAddress
-    ) external payable {
-        _dispatchWithGas(
-            _destinationDomain,
-            _messageBody,
-            _gasAmount,
-            _gasPayment,
-            _gasPaymentRefundAddress
-        );
-    }
 }

package/contracts/test/TestSendReceiver.sol

@@ -6,6 +6,11 @@ import {TypeCasts} from "../libs/TypeCasts.sol";
 import {IInterchainGasPaymaster} from "../interfaces/IInterchainGasPaymaster.sol";
 import {IMessageRecipient} from "../interfaces/IMessageRecipient.sol";
 import {IMailbox} from "../interfaces/IMailbox.sol";
+import {IPostDispatchHook} from "../interfaces/hooks/IPostDispatchHook.sol";
+import {IInterchainSecurityModule, ISpecifiesInterchainSecurityModule} from "../interfaces/IInterchainSecurityModule.sol";
+
+import {StandardHookMetadata} from "../hooks/libs/StandardHookMetadata.sol";
+import {MailboxClient} from "../client/MailboxClient.sol";
 
 contract TestSendReceiver is IMessageRecipient {
     using TypeCasts for address;
@@ -16,49 +21,47 @@ contract TestSendReceiver is IMessageRecipient {
 
     function dispatchToSelf(
         IMailbox _mailbox,
-        IInterchainGasPaymaster _paymaster,
         uint32 _destinationDomain,
         bytes calldata _messageBody
     ) external payable {
-        bytes32 _messageId = _mailbox.dispatch(
+        bytes memory hookMetadata = StandardHookMetadata.formatMetadata(
+            HANDLE_GAS_AMOUNT,
+            msg.sender
+        );
+        // TODO: handle topping up?
+        _mailbox.dispatch{value: msg.value}(
+            _destinationDomain,
+            address(this).addressToBytes32(),
+            _messageBody,
+            hookMetadata
+        );
+    }
+
+    function dispatchToSelf(
+        IMailbox _mailbox,
+        uint32 _destinationDomain,
+        bytes calldata _messageBody,
+        IPostDispatchHook hook
+    ) external payable {
+        bytes memory hookMetadata = StandardHookMetadata.formatMetadata(
+            HANDLE_GAS_AMOUNT,
+            msg.sender
+        );
+        // TODO: handle topping up?
+        _mailbox.dispatch{value: msg.value}(
             _destinationDomain,
             address(this).addressToBytes32(),
-            _messageBody
+            _messageBody,
+            hookMetadata,
+            hook
         );
-        uint256 _blockHashNum = uint256(previousBlockHash());
-        uint256 _value = msg.value;
-        if (_blockHashNum % 5 == 0) {
-            // Pay in two separate calls, resulting in 2 distinct events
-            uint256 _halfPayment = _value / 2;
-            uint256 _halfGasAmount = HANDLE_GAS_AMOUNT / 2;
-            _paymaster.payForGas{value: _halfPayment}(
-                _messageId,
-                _destinationDomain,
-                _halfGasAmount,
-                msg.sender
-            );
-            _paymaster.payForGas{value: _value - _halfPayment}(
-                _messageId,
-                _destinationDomain,
-                HANDLE_GAS_AMOUNT - _halfGasAmount,
-                msg.sender
-            );
-        } else {
-            // Pay the entire msg.value in one call
-            _paymaster.payForGas{value: _value}(
-                _messageId,
-                _destinationDomain,
-                HANDLE_GAS_AMOUNT,
-                msg.sender
-            );
-        }
     }
 
     function handle(
         uint32,
         bytes32,
         bytes calldata
-    ) external override {
+    ) external payable override {
         bytes32 blockHash = previousBlockHash();
         bool isBlockHashEndIn0 = uint256(blockHash) % 16 == 0;
         require(!isBlockHashEndIn0, "block hash ends in 0");

package/contracts/token/HypERC20.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+import {TokenRouter} from "./libs/TokenRouter.sol";
+
+import {ERC20Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
+
+/**
+ * @title Hyperlane ERC20 Token Router that extends ERC20 with remote transfer functionality.
+ * @author Abacus Works
+ * @dev Supply on each chain is not constant but the aggregate supply across all chains is.
+ */
+contract HypERC20 is ERC20Upgradeable, TokenRouter {
+    uint8 private immutable _decimals;
+
+    constructor(uint8 __decimals, address _mailbox) TokenRouter(_mailbox) {
+        _decimals = __decimals;
+    }
+
+    /**
+     * @notice Initializes the Hyperlane router, ERC20 metadata, and mints initial supply to deployer.
+     * @param _totalSupply The initial supply of the token.
+     * @param _name The name of the token.
+     * @param _symbol The symbol of the token.
+     */
+    function initialize(
+        uint256 _totalSupply,
+        string memory _name,
+        string memory _symbol
+    ) external initializer {
+        // Initialize ERC20 metadata
+        __ERC20_init(_name, _symbol);
+        _mint(msg.sender, _totalSupply);
+    }
+
+    function decimals() public view override returns (uint8) {
+        return _decimals;
+    }
+
+    function balanceOf(address _account)
+        public
+        view
+        virtual
+        override(TokenRouter, ERC20Upgradeable)
+        returns (uint256)
+    {
+        return ERC20Upgradeable.balanceOf(_account);
+    }
+
+    /**
+     * @dev Burns `_amount` of token from `msg.sender` balance.
+     * @inheritdoc TokenRouter
+     */
+    function _transferFromSender(uint256 _amount)
+        internal
+        override
+        returns (bytes memory)
+    {
+        _burn(msg.sender, _amount);
+        return bytes(""); // no metadata
+    }
+
+    /**
+     * @dev Mints `_amount` of token to `_recipient` balance.
+     * @inheritdoc TokenRouter
+     */
+    function _transferTo(
+        address _recipient,
+        uint256 _amount,
+        bytes calldata // no metadata
+    ) internal virtual override {
+        _mint(_recipient, _amount);
+    }
+}

package/contracts/token/HypERC20Collateral.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+import {TokenRouter} from "./libs/TokenRouter.sol";
+import {TokenMessage} from "./libs/TokenMessage.sol";
+import {MailboxClient} from "../client/MailboxClient.sol";
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+/**
+ * @title Hyperlane ERC20 Token Collateral that wraps an existing ERC20 with remote transfer functionality.
+ * @author Abacus Works
+ */
+contract HypERC20Collateral is TokenRouter {
+    using SafeERC20 for IERC20;
+
+    IERC20 public immutable wrappedToken;
+
+    /**
+     * @notice Constructor
+     * @param erc20 Address of the token to keep as collateral
+     */
+    constructor(address erc20, address _mailbox) TokenRouter(_mailbox) {
+        wrappedToken = IERC20(erc20);
+    }
+
+    function balanceOf(address _account)
+        external
+        view
+        override
+        returns (uint256)
+    {
+        return wrappedToken.balanceOf(_account);
+    }
+
+    /**
+     * @dev Transfers `_amount` of `wrappedToken` from `msg.sender` to this contract.
+     * @inheritdoc TokenRouter
+     */
+    function _transferFromSender(uint256 _amount)
+        internal
+        override
+        returns (bytes memory)
+    {
+        wrappedToken.safeTransferFrom(msg.sender, address(this), _amount);
+        return bytes(""); // no metadata
+    }
+
+    /**
+     * @dev Transfers `_amount` of `wrappedToken` from this contract to `_recipient`.
+     * @inheritdoc TokenRouter
+     */
+    function _transferTo(
+        address _recipient,
+        uint256 _amount,
+        bytes calldata // no metadata
+    ) internal virtual override {
+        wrappedToken.safeTransfer(_recipient, _amount);
+    }
+}

package/contracts/token/HypERC721.sol

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+import {TokenRouter} from "./libs/TokenRouter.sol";
+
+import {IERC721Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol";
+import {ERC721Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
+import {ERC721EnumerableUpgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
+
+/**
+ * @title Hyperlane ERC721 Token Router that extends ERC721 with remote transfer functionality.
+ * @author Abacus Works
+ */
+contract HypERC721 is ERC721EnumerableUpgradeable, TokenRouter {
+    constructor(address _mailbox) TokenRouter(_mailbox) {}
+
+    /**
+     * @notice Initializes the Hyperlane router, ERC721 metadata, and mints initial supply to deployer.
+     * @param _mintAmount The amount of NFTs to mint to `msg.sender`.
+     * @param _name The name of the token.
+     * @param _symbol The symbol of the token.
+     */
+    function initialize(
+        uint256 _mintAmount,
+        string memory _name,
+        string memory _symbol
+    ) external initializer {
+        address owner = msg.sender;
+        _transferOwnership(owner);
+
+        __ERC721_init(_name, _symbol);
+        for (uint256 i = 0; i < _mintAmount; i++) {
+            _safeMint(owner, i);
+        }
+    }
+
+    function balanceOf(address _account)
+        public
+        view
+        virtual
+        override(TokenRouter, ERC721Upgradeable, IERC721Upgradeable)
+        returns (uint256)
+    {
+        return ERC721Upgradeable.balanceOf(_account);
+    }
+
+    /**
+     * @dev Asserts `msg.sender` is owner and burns `_tokenId`.
+     * @inheritdoc TokenRouter
+     */
+    function _transferFromSender(uint256 _tokenId)
+        internal
+        virtual
+        override
+        returns (bytes memory)
+    {
+        require(ownerOf(_tokenId) == msg.sender, "!owner");
+        _burn(_tokenId);
+        return bytes(""); // no metadata
+    }
+
+    /**
+     * @dev Mints `_tokenId` to `_recipient`.
+     * @inheritdoc TokenRouter
+     */
+    function _transferTo(
+        address _recipient,
+        uint256 _tokenId,
+        bytes calldata // no metadata
+    ) internal virtual override {
+        _safeMint(_recipient, _tokenId);
+    }
+}

package/contracts/token/HypERC721Collateral.sol

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+import {TokenRouter} from "./libs/TokenRouter.sol";
+import {TokenMessage} from "./libs/TokenMessage.sol";
+
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+
+/**
+ * @title Hyperlane ERC721 Token Collateral that wraps an existing ERC721 with remote transfer functionality.
+ * @author Abacus Works
+ */
+contract HypERC721Collateral is TokenRouter {
+    IERC721 public immutable wrappedToken;
+
+    /**
+     * @notice Constructor
+     * @param erc721 Address of the token to keep as collateral
+     */
+    constructor(address erc721, address _mailbox) TokenRouter(_mailbox) {
+        wrappedToken = IERC721(erc721);
+    }
+
+    function ownerOf(uint256 _tokenId) external view returns (address) {
+        return IERC721(wrappedToken).ownerOf(_tokenId);
+    }
+
+    /**
+     * @dev Returns the balance of `_account` for `wrappedToken`.
+     * @inheritdoc TokenRouter
+     */
+    function balanceOf(address _account)
+        external
+        view
+        override
+        returns (uint256)
+    {
+        return IERC721(wrappedToken).balanceOf(_account);
+    }
+
+    /**
+     * @dev Transfers `_tokenId` of `wrappedToken` from `msg.sender` to this contract.
+     * @inheritdoc TokenRouter
+     */
+    function _transferFromSender(uint256 _tokenId)
+        internal
+        virtual
+        override
+        returns (bytes memory)
+    {
+        // safeTransferFrom not used here because recipient is this contract
+        wrappedToken.transferFrom(msg.sender, address(this), _tokenId);
+        return bytes(""); // no metadata
+    }
+
+    /**
+     * @dev Transfers `_tokenId` of `wrappedToken` from this contract to `_recipient`.
+     * @inheritdoc TokenRouter
+     */
+    function _transferTo(
+        address _recipient,
+        uint256 _tokenId,
+        bytes calldata // no metadata
+    ) internal override {
+        wrappedToken.safeTransferFrom(address(this), _recipient, _tokenId);
+    }
+}