refactored TempMultiwrap and TempPack

Author: Yash

contracts/feature/TokenBundle.sol

@@ -4,5 +4,47 @@ pragma solidity ^0.8.0;
 import "./interface/ITokenBundle.sol";
 
 abstract contract TokenBundle is ITokenBundle {
+    uint256 public nextTokenIdToMint;
+    mapping(uint256=>BundleInfo) public bundle;
+
+    function getTokenCount(uint256 tokenId) public view returns (uint256) {
+        return bundle[tokenId].count;
+    }
+
+    function getToken(uint256 tokenId, uint256 index) public view returns (Token memory) {
+        return bundle[tokenId].tokens[index];
+    }
+
+    function getUri(uint256 tokenId) public view returns (string memory) {
+        return bundle[tokenId].uri;
+    }
 
+    function _getNextTokenId() internal returns (uint256 nextTokenId) {
+        nextTokenId = nextTokenIdToMint;
+        nextTokenIdToMint += 1;
+    }
+
+    function _setBundle(Token[] calldata _tokensToBind, uint256 tokenId) internal {
+        for (uint256 i = 0; i < _tokensToBind.length; i += 1) {
+            bundle[tokenId].tokens[i] = _tokensToBind[i];
+        }
+        bundle[tokenId].count = _tokensToBind.length;
+    }
+
+    function _setBundleToken(Token memory _tokenToBind, uint256 tokenId, uint256 index) internal {
+        bundle[tokenId].tokens[index] = _tokenToBind;
+        bundle[tokenId].count += 1;
+    }
+
+    function _updateBundleToken(Token memory _tokenToBind, uint256 tokenId, uint256 index) internal {
+        bundle[tokenId].tokens[index] = _tokenToBind;
+    }
+
+    function _setUri(string calldata _uri, uint256 tokenId) internal {
+        bundle[tokenId].uri = _uri;
+    }
+
+    function _deleteBundle(uint256 tokenId) internal {
+        delete bundle[tokenId];
+    }
 }

contracts/feature/interface/ITokenBundle.sol

@@ -13,7 +13,7 @@ interface ITokenBundle {
         address assetContract;
         TokenType tokenType;
         uint256 tokenId;
-        uint256 totalAmountPacked;
+        uint256 totalAmount;
 
     }
 

contracts/multiwrap/ITempMultiwrap.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+import "../feature/interface/ITokenBundle.sol";
+
+/**
+ *  Thirdweb's Multiwrap contract lets you wrap arbitrary ERC20, ERC721 and ERC1155
+ *  tokens you own into a single wrapped token / NFT.
+ *
+ *  A wrapped NFT can be unwrapped i.e. burned in exchange for its underlying contents.
+ */
+
+interface ITempMultiwrap is ITokenBundle {
+    /// @notice The type of assets that can be wrapped.
+    // enum TokenType {
+    //     ERC20,
+    //     ERC721,
+    //     ERC1155
+    // }
+
+    /**
+     *  @notice A generic interface to describe a token to wrap.
+     *
+     *  @param assetContract The contract address of the asset to wrap.
+     *  @param tokenType     The token type (ERC20 / ERC721 / ERC1155) of the asset to wrap.
+     *  @param tokenId       The token Id of the asset to wrap, if the asset is an ERC721 / ERC1155 NFT.
+     *  @param amount        The amount of the asset to wrap, if the asset is an ERC20 / ERC1155 fungible token.
+     */
+    // struct Token {
+    //     address assetContract;
+    //     TokenType tokenType;
+    //     uint256 tokenId;
+    //     uint256 amount;
+    // }
+
+    /**
+     *  @notice An internal data structure to track the wrapped contents of a wrapped NFT.
+     *
+     *  @param count The total kinds of assets i.e. `Token` wrapped.
+     *  @param token Mapping from a UID -> to the asset i.e. `Token` at that UID.
+     */
+    // struct WrappedContents {
+    //     uint256 count;
+    //     mapping(uint256 => Token) token;
+    // }
+
+    /// @dev Emitted when tokens are wrapped.
+    event TokensWrapped(
+        address indexed wrapper,
+        address indexed recipientOfWrappedToken,
+        uint256 indexed tokenIdOfWrappedToken,
+        Token[] wrappedContents
+    );
+
+    /// @dev Emitted when tokens are unwrapped.
+    event TokensUnwrapped(
+        address indexed unwrapper,
+        address indexed recipientOfWrappedContents,
+        uint256 indexed tokenIdOfWrappedToken,
+        Token[] wrappedContents
+    );
+
+    /// @dev Emitted when the contract owner is updated.
+    event OwnerUpdated(address prevOwner, address newOwner);
+
+    /**
+     *  @notice Wrap multiple ERC1155, ERC721, ERC20 tokens into a single wrapped NFT.
+     *
+     *  @param wrappedContents    The tokens to wrap.
+     *  @param uriForWrappedToken The metadata URI for the wrapped NFT.
+     *  @param recipient          The recipient of the wrapped NFT.
+     */
+    function wrap(
+        Token[] memory wrappedContents,
+        string calldata uriForWrappedToken,
+        address recipient
+    ) external payable returns (uint256 tokenId);
+
+    /**
+     *  @notice Unwrap a wrapped NFT to retrieve underlying ERC1155, ERC721, ERC20 tokens.
+     *
+     *  @param tokenId   The token Id of the wrapped NFT to unwrap.
+     *  @param recipient The recipient of the underlying ERC1155, ERC721, ERC20 tokens of the wrapped NFT.
+     */
+    function unwrap(uint256 tokenId, address recipient) external;
+}

contracts/multiwrap/TempMultiwrap.sol

@@ -16,17 +16,20 @@ import "@openzeppelin/contracts-upgradeable/utils/MulticallUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/access/AccessControlEnumerableUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
 
+//  ==========  Feature imports    ==========//mychange
+import "../feature/TokenBundle.sol";
+
 //  ==========  Internal imports    ==========
 
 import "../interfaces/IThirdwebContract.sol";
 import "../interfaces/IThirdwebRoyalty.sol";
 import "../interfaces/IThirdwebOwnable.sol";
 
-import "../interfaces/IMultiwrap.sol";
+import "./ITempMultiwrap.sol";
 import "../lib/CurrencyTransferLib.sol";
 import "../openzeppelin-presets/metatx/ERC2771ContextUpgradeable.sol";
 
-contract Multiwrap is
+contract TempMultiwrap is
     IThirdwebContract,
     IThirdwebOwnable,
     IThirdwebRoyalty,
@@ -37,8 +40,9 @@ contract Multiwrap is
     ERC1155HolderUpgradeable,
     ERC721HolderUpgradeable,
     ERC721Upgradeable,
-    IMultiwrap
-{
+    ITempMultiwrap,
+    TokenBundle
+{//mychange TokenBundle
     /*///////////////////////////////////////////////////////////////
                             State variables
     //////////////////////////////////////////////////////////////*/
@@ -60,7 +64,8 @@ contract Multiwrap is
     address private immutable nativeTokenWrapper;
 
     /// @dev The next token ID of the NFT to mint.
-    uint256 public nextTokenIdToMint;
+    // uint256 public nextTokenIdToMint;
+    //mychange
 
     /// @dev The (default) address that receives all royalty value.
     address private royaltyRecipient;
@@ -85,7 +90,9 @@ contract Multiwrap is
     mapping(uint256 => string) private uri;
 
     /// @dev Mapping from tokenId of wrapped NFT => wrapped contents of the token.
-    mapping(uint256 => WrappedContents) private wrappedContents;
+    // mapping(uint256 => WrappedContents) private wrappedContents;
+    //mychange
+    // mapping(uint256=>BundleInfo) private bundle;
 
     /*///////////////////////////////////////////////////////////////
                     Constructor + initializer logic
@@ -163,7 +170,8 @@ contract Multiwrap is
 
     /// @dev Returns the URI for a given tokenId.
     function tokenURI(uint256 _tokenId) public view override returns (string memory) {
-        return uri[_tokenId];
+        // return uri[_tokenId]; //mychange
+        return getUri(_tokenId);
     }
 
     /// @dev See ERC 165
@@ -202,15 +210,23 @@ contract Multiwrap is
         string calldata _uriForWrappedToken,
         address _recipient
     ) external payable nonReentrant onlyMinter returns (uint256 tokenId) {
-        tokenId = nextTokenIdToMint;
-        nextTokenIdToMint += 1;
+        // tokenId = nextTokenIdToMint;
+        // nextTokenIdToMint += 1;
+        //mychange
+        tokenId = _getNextTokenId();
 
-        for (uint256 i = 0; i < _wrappedContents.length; i += 1) {
-            wrappedContents[tokenId].token[i] = _wrappedContents[i];
-        }
-        wrappedContents[tokenId].count = _wrappedContents.length;
+        _setBundle(_wrappedContents, tokenId); //mychange
+
+        //mychange
+        // for (uint256 i = 0; i < _wrappedContents.length; i += 1) {
+        //     bundle[tokenId].tokens[i] = _wrappedContents[i];
+        // }
+        // wrappedContents[tokenId].count = _wrappedContents.length;
 
-        uri[tokenId] = _uriForWrappedToken;
+        //mychange
+        // uri[tokenId] = _uriForWrappedToken; 
+
+        _setUri(_uriForWrappedToken, tokenId);
 
         _safeMint(_recipient, tokenId);
 
@@ -230,15 +246,19 @@ contract Multiwrap is
 
         _burn(_tokenId);
 
-        uint256 count = wrappedContents[_tokenId].count;
+        // uint256 count = wrappedContents[_tokenId].count; //mychange
+
+        uint256 count = getTokenCount(_tokenId);
         Token[] memory tokensUnwrapped = new Token[](count);
 
         for (uint256 i = 0; i < count; i += 1) {
-            tokensUnwrapped[i] = wrappedContents[_tokenId].token[i];
+            // tokensUnwrapped[i] = wrappedContents[_tokenId].token[i]; //mychange
+            tokensUnwrapped[i] = getToken(_tokenId, i);
             transferToken(address(this), _recipient, tokensUnwrapped[i]);
         }
 
-        delete wrappedContents[_tokenId];
+        // delete wrappedContents[_tokenId]; //mychange
+        _deleteBundle(_tokenId);
 
         emit TokensUnwrapped(_msgSender(), _recipient, _tokenId, tokensUnwrapped);
     }
@@ -254,14 +274,16 @@ contract Multiwrap is
                 _token.assetContract,
                 _from,
                 _to,
-                _token.amount,
+                _token.totalAmount,
                 nativeTokenWrapper
             );
         } else if (_token.tokenType == TokenType.ERC721) {
             IERC721Upgradeable(_token.assetContract).safeTransferFrom(_from, _to, _token.tokenId);
         } else if (_token.tokenType == TokenType.ERC1155) {
-            IERC1155Upgradeable(_token.assetContract).safeTransferFrom(_from, _to, _token.tokenId, _token.amount, "");
+            IERC1155Upgradeable(_token.assetContract).safeTransferFrom(_from, _to, _token.tokenId, _token.totalAmount, "");
         }
+
+        //mychange _token.amount now _token.totalAmount
     }
 
     /// @dev Transfers multiple arbitrary ERC20 / ERC721 / ERC1155 tokens.
@@ -296,11 +318,13 @@ contract Multiwrap is
 
     /// @dev Returns the underlygin contents of a wrapped NFT.
     function getWrappedContents(uint256 _tokenId) external view returns (Token[] memory contents) {
-        uint256 total = wrappedContents[_tokenId].count;
+        //mychange
+        uint256 total = getTokenCount(_tokenId);
         contents = new Token[](total);
 
+        //mychange
         for(uint256 i = 0; i < total; i += 1) {
-            contents[i] = wrappedContents[_tokenId].token[i];
+            contents[i] = getToken(_tokenId, i);
         }
     }