Add upgradeable versions of SignatureMint contracts

Krishang Nadgauda · Krishang Nadgauda · commit 92deebd6d909 · 2022-04-29T18:38:27.000-04:00
diff --git a/contracts/feature/SignatureMintERC1155Upgradeable.sol b/contracts/feature/SignatureMintERC1155Upgradeable.sol
@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import "./interface/ISignatureMintERC1155.sol";
+
+import "@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";
+
+abstract contract SignatureMintERC1155Upgradeable is Initializable, EIP712Upgradeable, ISignatureMintERC1155 {
+    using ECDSAUpgradeable for bytes32;
+
+    bytes32 internal constant TYPEHASH =
+        keccak256(
+            "MintRequest(address to,address royaltyRecipient,uint256 royaltyBps,address primarySaleRecipient,uint256 tokenId,string uri,uint256 quantity,uint256 pricePerToken,address currency,uint128 validityStartTimestamp,uint128 validityEndTimestamp,bytes32 uid)"
+        );
+
+    /// @dev Mapping from mint request UID => whether the mint request is processed.
+    mapping(bytes32 => bool) private minted;
+
+    function __SignatureMintERC1155_init() internal onlyInitializing {
+        __EIP712_init("SignatureMintERC1155", "1");
+    }
+
+    function __SignatureMintERC1155_init_unchained() internal onlyInitializing {}
+
+    /// @dev Verifies that a mint request is signed by an account holding MINTER_ROLE (at the time of the function call).
+    function verify(MintRequest calldata _req, bytes calldata _signature)
+        public
+        view
+        returns (bool success, address signer)
+    {
+        signer = _recoverAddress(_req, _signature);
+        success = !minted[_req.uid] && _isAuthorizedSigner(signer);
+    }
+
+    /// @dev Returns whether a given address is authorized to sign mint requests.
+    function _isAuthorizedSigner(address _signer) internal view virtual returns (bool);
+
+    /// @dev Verifies a mint request and marks the request as minted.
+    function _processRequest(MintRequest calldata _req, bytes calldata _signature)
+        internal
+        returns (address signer)
+    {
+        bool success;
+        (success, signer) = verify(_req, _signature);
+
+        require(success, "Invalid request");
+        require(
+            _req.validityStartTimestamp <= block.timestamp  && block.timestamp <= _req.validityEndTimestamp,
+            "Request expired"
+        );
+
+        minted[_req.uid] = true;
+    }
+
+    /// @dev Returns the address of the signer of the mint request.
+    function _recoverAddress(MintRequest calldata _req, bytes calldata _signature) internal view returns (address) {
+        return _hashTypedDataV4(keccak256(_encodeRequest(_req))).recover(_signature);
+    }
+
+    /// @dev Resolves 'stack too deep' error in `recoverAddress`.
+    function _encodeRequest(MintRequest calldata _req) internal pure returns (bytes memory) {
+        return
+            abi.encode(
+                TYPEHASH,
+                _req.to,
+                _req.royaltyRecipient,
+                _req.royaltyBps,
+                _req.primarySaleRecipient,
+                _req.tokenId,
+                keccak256(bytes(_req.uri)),
+                _req.quantity,
+                _req.pricePerToken,
+                _req.currency,
+                _req.validityStartTimestamp,
+                _req.validityEndTimestamp,
+                _req.uid
+            );
+    }
+}
diff --git a/contracts/feature/SignatureMintERC20Upgradeable.sol b/contracts/feature/SignatureMintERC20Upgradeable.sol
@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import "./interface/ISignatureMintERC20.sol";
+
+import "@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";
+
+abstract contract SignatureMintERC20Upgradeable is Initializable, EIP712Upgradeable, ISignatureMintERC20 {
+    using ECDSAUpgradeable for bytes32;
+
+    bytes32 private constant TYPEHASH =
+        keccak256(
+            "MintRequest(address to,address primarySaleRecipient,uint256 quantity,uint256 pricePerToken,address currency,uint128 validityStartTimestamp,uint128 validityEndTimestamp,bytes32 uid)"
+        );
+
+    /// @dev Mapping from mint request UID => whether the mint request is processed.
+    mapping(bytes32 => bool) private minted;
+
+    function __SignatureMintERC20_init() internal onlyInitializing {
+        __EIP712_init("SignatureMintERC20", "1");
+    }
+
+    function __SignatureMintERC20_init_unchained() internal onlyInitializing {}
+
+    /// @dev Verifies that a mint request is signed by an account holding MINTER_ROLE (at the time of the function call).
+    function verify(MintRequest calldata _req, bytes calldata _signature)
+        public
+        view
+        returns (bool success, address signer)
+    {
+        signer = _recoverAddress(_req, _signature);
+        success = !minted[_req.uid] && _isAuthorizedSigner(signer);
+    }
+
+    /// @dev Returns whether a given address is authorized to sign mint requests.
+    function _isAuthorizedSigner(address _signer) internal view virtual returns (bool);
+
+    /// @dev Verifies a mint request and marks the request as minted.
+    function _processRequest(MintRequest calldata _req, bytes calldata _signature)
+        internal
+        returns (address signer)
+    {
+        bool success;
+        (success, signer) = verify(_req, _signature);
+
+        require(success, "Invalid request");
+        require(
+            _req.validityStartTimestamp <= block.timestamp  && block.timestamp <= _req.validityEndTimestamp,
+            "Request expired"
+        );
+
+        minted[_req.uid] = true;
+    }
+
+    /// @dev Returns the address of the signer of the mint request.
+    function _recoverAddress(MintRequest calldata _req, bytes calldata _signature) internal view returns (address) {
+        return _hashTypedDataV4(keccak256(_encodeRequest(_req))).recover(_signature);
+    }
+
+    /// @dev Resolves 'stack too deep' error in `recoverAddress`.
+    function _encodeRequest(MintRequest calldata _req) internal pure returns (bytes memory) {
+        return
+            abi.encode(
+                TYPEHASH,
+                _req.to,
+                _req.primarySaleRecipient,
+                _req.quantity,
+                _req.pricePerToken,
+                _req.currency,
+                _req.validityStartTimestamp,
+                _req.validityEndTimestamp,
+                _req.uid
+            );
+    }
+}
diff --git a/contracts/feature/SignatureMintERC721Upgradeable.sol b/contracts/feature/SignatureMintERC721Upgradeable.sol
@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import "./interface/ISignatureMintERC721.sol";
+
+import "@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";
+
+abstract contract SignatureMintERC721Upgradeable is Initializable, EIP712Upgradeable, ISignatureMintERC721 {
+    using ECDSAUpgradeable for bytes32;
+
+    bytes32 private constant TYPEHASH =
+        keccak256(
+            "MintRequest(address to,address royaltyRecipient,uint256 royaltyBps,address primarySaleRecipient,string uri,uint256 quantity,uint256 price,address currency,uint128 validityStartTimestamp,uint128 validityEndTimestamp,bytes32 uid)"
+        );
+
+    /// @dev Mapping from mint request UID => whether the mint request is processed.
+    mapping(bytes32 => bool) private minted;
+
+    function __SignatureMintERC721_init() internal onlyInitializing {
+        __EIP712_init("SignatureMintERC721", "1");
+    }
+
+    function __SignatureMintERC721_init_unchained() internal onlyInitializing {}
+
+    /// @dev Verifies that a mint request is signed by an account holding MINTER_ROLE (at the time of the function call).
+    function verify(MintRequest calldata _req, bytes calldata _signature)
+        public
+        view
+        returns (bool success, address signer)
+    {
+        signer = _recoverAddress(_req, _signature);
+        success = !minted[_req.uid] && _isAuthorizedSigner(signer);
+    }
+
+    /// @dev Returns whether a given address is authorized to sign mint requests.
+    function _isAuthorizedSigner(address _signer) internal view virtual returns (bool);
+
+    /// @dev Verifies a mint request and marks the request as minted.
+    function _processRequest(MintRequest calldata _req, bytes calldata _signature)
+        internal
+        returns (address signer)
+    {
+        bool success;
+        (success, signer) = verify(_req, _signature);
+
+        require(success, "Invalid request");
+        require(
+            _req.validityStartTimestamp <= block.timestamp  && block.timestamp <= _req.validityEndTimestamp,
+            "Request expired"
+        );
+
+        minted[_req.uid] = true;
+    }
+
+    /// @dev Returns the address of the signer of the mint request.
+    function _recoverAddress(MintRequest calldata _req, bytes calldata _signature) internal view returns (address) {
+        return _hashTypedDataV4(keccak256(_encodeRequest(_req))).recover(_signature);
+    }
+
+    /// @dev Resolves 'stack too deep' error in `recoverAddress`.
+    function _encodeRequest(MintRequest calldata _req) internal pure returns (bytes memory) {
+        return
+            abi.encode(
+                TYPEHASH,
+                _req.to,
+                _req.royaltyRecipient,
+                _req.royaltyBps,
+                _req.primarySaleRecipient,
+                keccak256(bytes(_req.uri)),
+                _req.quantity,
+                _req.pricePerToken,
+                _req.currency,
+                _req.validityStartTimestamp,
+                _req.validityEndTimestamp,
+                _req.uid
+            );
+    }
+}
diff --git a/docs/SignatureMintERC20Upgradeable.md b/docs/SignatureMintERC20Upgradeable.md
@@ -0,0 +1,77 @@
+# SignatureMintERC20Upgradeable
+
+
+
+
+
+
+
+
+
+## Methods
+
+### mintWithSignature
+
+```solidity
+function mintWithSignature(ISignatureMintERC20.MintRequest req, bytes signature) external payable
+```
+
+Mints tokens according to the provided mint request.
+
+
+
+#### Parameters
+
+| Name | Type | Description |
+|---|---|---|
+| req | ISignatureMintERC20.MintRequest | The payload / mint request.
+| signature | bytes | The signature produced by an account signing the mint request.
+
+### verify
+
+```solidity
+function verify(ISignatureMintERC20.MintRequest _req, bytes _signature) external view returns (bool success, address signer)
+```
+
+
+
+*Verifies that a mint request is signed by an account holding MINTER_ROLE (at the time of the function call).*
+
+#### Parameters
+
+| Name | Type | Description |
+|---|---|---|
+| _req | ISignatureMintERC20.MintRequest | undefined
+| _signature | bytes | undefined
+
+#### Returns
+
+| Name | Type | Description |
+|---|---|---|
+| success | bool | undefined
+| signer | address | undefined
+
+
+
+## Events
+
+### TokensMintedWithSignature
+
+```solidity
+event TokensMintedWithSignature(address indexed signer, address indexed mintedTo, ISignatureMintERC20.MintRequest mintRequest)
+```
+
+
+
+
+
+#### Parameters
+
+| Name | Type | Description |
+|---|---|---|
+| signer `indexed` | address | undefined |
+| mintedTo `indexed` | address | undefined |
+| mintRequest  | ISignatureMintERC20.MintRequest | undefined |
+
+
+
