enterprise contract (#26)

* create base contract for contentsign

* ClickContentSign based on BaseContentSign

* add enterprise contentsign

Author: ETeissonniere

script/DeployContentSign.s.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.20;
 import {Script, console} from "forge-std/Script.sol";
 
 import {WhitelistPaymaster} from "../src/paymasters/WhitelistPaymaster.sol";
-import {ContentSignNFT} from "../src/contentsign/ContentSignNFT.sol";
+import {ClickContentSign} from "../src/contentsign/ClickContentSign.sol";
 
 contract DeployContentSign is Script {
     address internal whitelistAdmin;
@@ -22,7 +22,7 @@ contract DeployContentSign is Script {
         vm.startBroadcast();
 
         WhitelistPaymaster paymaster = new WhitelistPaymaster(withdrawer);
-        ContentSignNFT nft = new ContentSignNFT("ContentSign", "SIGNED", paymaster);
+        ClickContentSign nft = new ClickContentSign("ContentSign", "SIGNED", paymaster);
 
         address[] memory whitelist = new address[](1);
         whitelist[0] = address(nft);
@@ -35,7 +35,7 @@ contract DeployContentSign is Script {
 
         vm.stopBroadcast();
 
-        console.log("Deployed ContentSignNFT at %s", address(nft));
+        console.log("Deployed ClickContentSign at %s", address(nft));
         console.log("Deployed WhitelistPaymaster at %s", address(paymaster));
         console.log("Please ensure you fund the paymaster contract with enough ETH!");
     }

src/contentsign/ContentSignNFT.sol src/contentsign/BaseContentSign.solsrc/contentsign/ContentSignNFT.sol renamed to src/contentsign/BaseContentSign.sol

@@ -8,16 +8,13 @@ import {ERC721URIStorage} from "openzeppelin-contracts/contracts/token/ERC721/ex
 import {WhitelistPaymaster} from "../paymasters/WhitelistPaymaster.sol";
 
 /// @notice a simple NFT contract for contentsign data where each nft is mapped to a one-time
-/// configurable URL
-contract ContentSignNFT is ERC721, ERC721URIStorage {
+/// configurable URL. This is used for every variant of ContentSign with associated hooks.
+abstract contract BaseContentSign is ERC721, ERC721URIStorage {
     uint256 public nextTokenId;
-    WhitelistPaymaster public whitelistPaymaster;
 
-    error UserIsNotWhitelisted();
+    error UserIsNotWhitelisted(address user);
 
-    constructor(string memory name, string memory symbol, WhitelistPaymaster whitelist) ERC721(name, symbol) {
-        whitelistPaymaster = whitelist;
-    }
+    constructor(string memory name, string memory symbol) ERC721(name, symbol) {}
 
     function safeMint(address to, string memory uri) public {
         _mustBeWhitelisted();
@@ -31,13 +28,21 @@ contract ContentSignNFT is ERC721, ERC721URIStorage {
         return super.tokenURI(tokenId);
     }
 
-    function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721URIStorage) returns (bool) {
-        return super.supportsInterface(interfaceId);
+    function supportsInterface(bytes4 interfaceId)
+        public
+        view
+        virtual
+        override(ERC721, ERC721URIStorage)
+        returns (bool)
+    {
+        return ERC721.supportsInterface(interfaceId) || ERC721URIStorage.supportsInterface(interfaceId);
     }
 
     function _mustBeWhitelisted() internal view {
-        if (!whitelistPaymaster.isWhitelistedUser(msg.sender)) {
-            revert UserIsNotWhitelisted();
+        if (!_userIsWhitelisted(msg.sender)) {
+            revert UserIsNotWhitelisted(msg.sender);
         }
     }
+
+    function _userIsWhitelisted(address user) internal view virtual returns (bool);
 }

src/contentsign/ClickContentSign.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+
+pragma solidity ^0.8.20;
+
+import {BaseContentSign} from "./BaseContentSign.sol";
+import {WhitelistPaymaster} from "../paymasters/WhitelistPaymaster.sol";
+
+/// @notice the content sign contract variant for Click. Only users whitelisted on the paymaster can mint tokens
+contract ClickContentSign is BaseContentSign {
+    WhitelistPaymaster public whitelistPaymaster;
+
+    constructor(string memory name, string memory symbol, WhitelistPaymaster whitelist) BaseContentSign(name, symbol) {
+        whitelistPaymaster = whitelist;
+    }
+
+    function _userIsWhitelisted(address user) internal view override returns (bool) {
+        return whitelistPaymaster.isWhitelistedUser(user);
+    }
+}

src/contentsign/EnterpriseContentSign.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+
+pragma solidity ^0.8.20;
+
+import {BaseContentSign} from "./BaseContentSign.sol";
+
+import {AccessControl} from "openzeppelin-contracts/contracts/access/AccessControl.sol";
+
+/// @notice the content sign contract variant for enterprises. Only users whitelisted on this contract can mint
+contract EnterpriseContentSign is BaseContentSign, AccessControl {
+    bytes32 public constant WHITELISTED_ROLE = keccak256("WHITELISTED_ROLE");
+
+    constructor(string memory name, string memory symbol) BaseContentSign(name, symbol) {
+        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
+    }
+
+    function supportsInterface(bytes4 interfaceId)
+        public
+        view
+        override(BaseContentSign, AccessControl)
+        returns (bool)
+    {
+        return BaseContentSign.supportsInterface(interfaceId) || AccessControl.supportsInterface(interfaceId);
+    }
+
+    function _userIsWhitelisted(address user) internal view override returns (bool) {
+        return hasRole(WHITELISTED_ROLE, user);
+    }
+}

test/contentsign/BaseContentSign.t.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+
+pragma solidity ^0.8.20;
+
+import {Test, console} from "forge-std/Test.sol";
+import {BaseContentSign} from "../../src/contentsign/BaseContentSign.sol";
+
+contract MockContentSign is BaseContentSign {
+    bool public whitelisted = false;
+
+    constructor() BaseContentSign("Mock", "MOCK") {}
+
+    function setWhitelisted(bool _whitelisted) public {
+        whitelisted = _whitelisted;
+    }
+
+    function _userIsWhitelisted(address) internal view override returns (bool) {
+        return whitelisted;
+    }
+}
+
+contract BaseContentSignTest is Test {
+    MockContentSign private contentSign;
+
+    address internal alice = vm.addr(1);
+
+    function setUp() public {
+        contentSign = new MockContentSign();
+    }
+
+    function test_setsMetadata() public {
+        assertEq(contentSign.name(), "Mock");
+        assertEq(contentSign.symbol(), "MOCK");
+    }
+
+    function test_whitelistedCanMint() public {
+        contentSign.setWhitelisted(true);
+        contentSign.safeMint(alice, "uri");
+
+        assertEq(contentSign.ownerOf(0), alice);
+        assertEq(contentSign.tokenURI(0), "uri");
+    }
+
+    function test_nonWhitelistedCannotMint() public {
+        contentSign.setWhitelisted(false);
+
+        vm.expectRevert(abi.encodeWithSelector(BaseContentSign.UserIsNotWhitelisted.selector, alice));
+        vm.prank(alice);
+        contentSign.safeMint(alice, "uri");
+    }
+}

test/contentsign/ContentSignNFT.t.sol test/contentsign/ClickContentSign.t.soltest/contentsign/ContentSignNFT.t.sol renamed to test/contentsign/ClickContentSign.t.sol

@@ -3,20 +3,21 @@
 pragma solidity ^0.8.20;
 
 import {Test, console} from "forge-std/Test.sol";
-import {ContentSignNFT} from "../../src/contentsign/ContentSignNFT.sol";
+import {BaseContentSign} from "../../src/contentsign/BaseContentSign.sol";
+import {ClickContentSign} from "../../src/contentsign/ClickContentSign.sol";
 import {WhitelistPaymaster} from "../../src/paymasters/WhitelistPaymaster.sol";
 
-contract ContentSignNFTTest is Test {
+contract ClickContentSignTest is Test {
     WhitelistPaymaster private paymaster;
-    ContentSignNFT private nft;
+    ClickContentSign private nft;
 
     address internal alice = vm.addr(1);
     address internal bob = vm.addr(2);
 
     function setUp() public {
         vm.prank(alice);
         paymaster = new WhitelistPaymaster(alice);
-        nft = new ContentSignNFT("Name", "Symbol", paymaster);
+        nft = new ClickContentSign("Name", "Symbol", paymaster);
 
         address[] memory contracts = new address[](1);
         contracts[0] = address(nft);
@@ -41,7 +42,7 @@ contract ContentSignNFTTest is Test {
     function test_nonWhitelistedCannotMint() public {
         address charlie = vm.addr(3);
 
-        vm.expectRevert(ContentSignNFT.UserIsNotWhitelisted.selector);
+        vm.expectRevert(abi.encodeWithSelector(BaseContentSign.UserIsNotWhitelisted.selector, charlie));
         vm.prank(charlie);
         nft.safeMint(charlie, "uri");
     }

test/contentsign/EnterpriseContentSign.t.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+
+pragma solidity ^0.8.20;
+
+import {Test, console} from "forge-std/Test.sol";
+import {BaseContentSign} from "../../src/contentsign/BaseContentSign.sol";
+import {EnterpriseContentSign} from "../../src/contentsign/EnterpriseContentSign.sol";
+
+contract EnterpriseContentSignTest is Test {
+    EnterpriseContentSign private nft;
+
+    address internal alice = vm.addr(1);
+    address internal bob = vm.addr(2);
+
+    function setUp() public {
+        vm.startPrank(alice);
+        nft = new EnterpriseContentSign("Name", "Symbol");
+        nft.grantRole(nft.WHITELISTED_ROLE(), bob);
+        vm.stopPrank();
+    }
+
+    function sets_adminRole() public {
+        assertEq(nft.hasRole(nft.DEFAULT_ADMIN_ROLE(), alice), true);
+    }
+
+    function test_whitelistedUserCanMint() public {
+        assertEq(nft.hasRole(nft.WHITELISTED_ROLE(), bob), true);
+
+        vm.prank(bob);
+        nft.safeMint(bob, "uri");
+
+        assertEq(nft.ownerOf(0), bob);
+        assertEq(nft.tokenURI(0), "uri");
+    }
+
+    function test_nonWhitelistedCannotMint() public {
+        address charlie = vm.addr(3);
+
+        vm.expectRevert(abi.encodeWithSelector(BaseContentSign.UserIsNotWhitelisted.selector, charlie));
+        vm.prank(charlie);
+        nft.safeMint(charlie, "uri");
+    }
+}