Add URI support (#12)

* Add HypERC721URIStorage

* Add HypERC721URICollateral

contracts/HypERC20.sol

@@ -6,7 +6,7 @@ import {TokenRouter} from "./libs/TokenRouter.sol";
 import {ERC20Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
 
 /**
- * @title Hyperlane Token that extends the ERC20 token standard to enable native interchain transfers.
+ * @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.
  */
@@ -40,16 +40,28 @@ contract HypERC20 is ERC20Upgradeable, TokenRouter {
         _mint(msg.sender, _totalSupply);
     }
 
-    // called in `TokenRouter.transferRemote` before `Mailbox.dispatch`
-    function _transferFromSender(uint256 _amount) internal override {
-        _burn(msg.sender, _amount);
-    }
-
-    // called by `TokenRouter.handle`
-    function _transferTo(address _recipient, uint256 _amount)
+    /**
+     * @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 override {
         _mint(_recipient, _amount);
     }
 }

contracts/HypERC20Collateral.sol

@@ -6,7 +6,7 @@ import {TokenRouter} from "./libs/TokenRouter.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 
 /**
- * @title Collateralize ERC20 token and route messages to HypERC20 tokens.
+ * @title Hyperlane ERC20 Token Collateral that wraps an existing ERC20 with remote transfer functionality.
  * @author Abacus Works
  */
 contract HypERC20Collateral is TokenRouter {
@@ -16,6 +16,12 @@ contract HypERC20Collateral is TokenRouter {
         wrappedToken = IERC20(erc20);
     }
 
+    /**
+     * @notice Initializes the Hyperlane router.
+     * @param _mailbox The address of the mailbox contract.
+     * @param _interchainGasPaymaster The address of the interchain gas paymaster contract.
+     * @param _interchainSecurityModule The address of the interchain security module contract.
+     */
     function initialize(
         address _mailbox,
         address _interchainGasPaymaster,
@@ -28,14 +34,31 @@ contract HypERC20Collateral is TokenRouter {
         );
     }
 
-    function _transferFromSender(uint256 _amount) internal override {
-        require(wrappedToken.transferFrom(msg.sender, address(this), _amount));
-    }
-
-    function _transferTo(address _recipient, uint256 _amount)
+    /**
+     * @dev Transfers `_amount` of `wrappedToken` from `msg.sender` to this contract.
+     * @inheritdoc TokenRouter
+     */
+    function _transferFromSender(uint256 _amount)
         internal
         override
+        returns (bytes memory)
     {
-        require(wrappedToken.transfer(_recipient, _amount));
+        require(
+            wrappedToken.transferFrom(msg.sender, address(this), _amount),
+            "!transferFrom"
+        );
+        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 override {
+        require(wrappedToken.transfer(_recipient, _amount), "!transfer");
     }
 }

contracts/HypERC721.sol

@@ -6,7 +6,7 @@ import {TokenRouter} from "./libs/TokenRouter.sol";
 import {ERC721EnumerableUpgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
 
 /**
- * @title Hyperlane Token that extends the ERC721 token standard to enable native interchain transfers.
+ * @title Hyperlane ERC721 Token Router that extends ERC721 with remote transfer functionality.
  * @author Abacus Works
  */
 contract HypERC721 is ERC721EnumerableUpgradeable, TokenRouter {
@@ -40,17 +40,30 @@ contract HypERC721 is ERC721EnumerableUpgradeable, TokenRouter {
         }
     }
 
-    // called in `TokenRouter.transferRemote` before `Mailbox.dispatch`
-    function _transferFromSender(uint256 _tokenId) internal override {
+    /**
+     * @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
     }
 
-    // called by `TokenRouter.handle`
-    function _transferTo(address _recipient, uint256 _tokenId)
-        internal
-        override
-    {
+    /**
+     * @dev Mints `_tokenId` to `_recipient`.
+     * @inheritdoc TokenRouter
+     */
+    function _transferTo(
+        address _recipient,
+        uint256 _tokenId,
+        bytes calldata // no metadata
+    ) internal virtual override {
         _mint(_recipient, _tokenId);
     }
 }

contracts/HypERC721Collateral.sol

@@ -6,16 +6,22 @@ import {TokenRouter} from "./libs/TokenRouter.sol";
 import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
 
 /**
- * @title Collateralize ERC20 token and route messages to HypERC20 tokens.
+ * @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;
+    address public immutable wrappedToken;
 
     constructor(address erc721) {
-        wrappedToken = IERC721(erc721);
+        wrappedToken = erc721;
     }
 
+    /**
+     * @notice Initializes the Hyperlane router.
+     * @param _mailbox The address of the mailbox contract.
+     * @param _interchainGasPaymaster The address of the interchain gas paymaster contract.
+     * @param _interchainSecurityModule The address of the interchain security module contract.
+     */
     function initialize(
         address _mailbox,
         address _interchainGasPaymaster,
@@ -28,14 +34,29 @@ contract HypERC721Collateral is TokenRouter {
         );
     }
 
-    function _transferFromSender(uint256 _amount) internal override {
-        wrappedToken.transferFrom(msg.sender, address(this), _amount);
-    }
-
-    function _transferTo(address _recipient, uint256 _amount)
+    /**
+     * @dev Transfers `_tokenId` of `wrappedToken` from `msg.sender` to this contract.
+     * @inheritdoc TokenRouter
+     */
+    function _transferFromSender(uint256 _tokenId)
         internal
+        virtual
         override
+        returns (bytes memory)
     {
-        wrappedToken.transferFrom(address(this), _recipient, _amount);
+        IERC721(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 {
+        IERC721(wrappedToken).transferFrom(address(this), _recipient, _tokenId);
     }
 }

contracts/extensions/HypERC721URICollateral.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+import {HypERC721Collateral} from "../HypERC721Collateral.sol";
+
+import {IERC721MetadataUpgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol";
+
+/**
+ * @title Hyperlane ERC721 Token Collateral that wraps an existing ERC721 with remote transfer and URI relay functionality.
+ * @author Abacus Works
+ */
+contract HypERC721URICollateral is HypERC721Collateral {
+    constructor(address erc721) HypERC721Collateral(erc721) {}
+
+    /**
+     * @dev Transfers `_tokenId` of `wrappedToken` from `msg.sender` to this contract.
+     * @return The URI of `_tokenId` on `wrappedToken`.
+     * @inheritdoc HypERC721Collateral
+     */
+    function _transferFromSender(uint256 _tokenId)
+        internal
+        override
+        returns (bytes memory)
+    {
+        HypERC721Collateral._transferFromSender(_tokenId);
+        return
+            bytes(IERC721MetadataUpgradeable(wrappedToken).tokenURI(_tokenId));
+    }
+}

contracts/extensions/HypERC721URIStorage.sol

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+import {HypERC721} from "../HypERC721.sol";
+
+import {ERC721URIStorageUpgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721URIStorageUpgradeable.sol";
+import {ERC721EnumerableUpgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
+import {ERC721Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
+
+/**
+ * @title Hyperlane ERC721 Token that extends ERC721URIStorage with remote transfer and URI relay functionality.
+ * @author Abacus Works
+ */
+contract HypERC721URIStorage is HypERC721, ERC721URIStorageUpgradeable {
+    /**
+     * @return _tokenURI The URI of `_tokenId`.
+     * @inheritdoc HypERC721
+     */
+    function _transferFromSender(uint256 _tokenId)
+        internal
+        override
+        returns (bytes memory _tokenURI)
+    {
+        _tokenURI = bytes(tokenURI(_tokenId)); // requires minted
+        HypERC721._transferFromSender(_tokenId);
+    }
+
+    /**
+     * @dev Sets the URI for `_tokenId` to `_tokenURI`.
+     * @inheritdoc HypERC721
+     */
+    function _transferTo(
+        address _recipient,
+        uint256 _tokenId,
+        bytes calldata _tokenURI
+    ) internal override {
+        HypERC721._transferTo(_recipient, _tokenId, _tokenURI);
+        _setTokenURI(_tokenId, string(_tokenURI)); // requires minted
+    }
+
+    function tokenURI(uint256 tokenId)
+        public
+        view
+        override(ERC721Upgradeable, ERC721URIStorageUpgradeable)
+        returns (string memory)
+    {
+        return ERC721URIStorageUpgradeable.tokenURI(tokenId);
+    }
+
+    function _beforeTokenTransfer(
+        address from,
+        address to,
+        uint256 tokenId
+    ) internal override(ERC721EnumerableUpgradeable, ERC721Upgradeable) {
+        ERC721EnumerableUpgradeable._beforeTokenTransfer(from, to, tokenId);
+    }
+
+    function supportsInterface(bytes4 interfaceId)
+        public
+        view
+        override(ERC721EnumerableUpgradeable, ERC721Upgradeable)
+        returns (bool)
+    {
+        return ERC721EnumerableUpgradeable.supportsInterface(interfaceId);
+    }
+
+    function _burn(uint256 tokenId)
+        internal
+        override(ERC721URIStorageUpgradeable, ERC721Upgradeable)
+    {
+        ERC721URIStorageUpgradeable._burn(tokenId);
+    }
+}

contracts/libs/Message.sol

@@ -2,12 +2,12 @@
 pragma solidity >=0.8.0;
 
 library Message {
-    function format(bytes32 _recipient, uint256 _amount)
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodePacked(_recipient, _amount);
+    function format(
+        bytes32 _recipient,
+        uint256 _amount,
+        bytes memory _metadata
+    ) internal pure returns (bytes memory) {
+        return abi.encodePacked(_recipient, _amount, _metadata);
     }
 
     function recipient(bytes calldata message) internal pure returns (bytes32) {
@@ -22,4 +22,12 @@ library Message {
     function tokenId(bytes calldata message) internal pure returns (uint256) {
         return amount(message);
     }
+
+    function metadata(bytes calldata message)
+        internal
+        pure
+        returns (bytes calldata)
+    {
+        return message[64:];
+    }
 }