[chore] custome errors (#57)

Author: jasonzwli

contracts/errors/Errors.sol

@@ -0,0 +1,17 @@
+pragma solidity ^0.8.0;
+
+interface IImmutableERC721Errors {
+    /// @dev Caller tried to mint an already burned token
+    error IImmutableERC721TokenAlreadyBurned(uint256 tokenId);
+
+    /// @dev Caller tried to mint an already burned token
+    error IImmutableERC721SendingToZerothAddress();
+
+    /// @dev Caller tried to mint an already burned token
+    error IImmutableERC721MismatchedTransferLengths();
+}
+
+interface RoyaltyEnforcementErrors {
+    /// @dev Caller tried to mint an already burned token
+    error RoyaltyEnforcementDoesNotImplementRequiredInterface();
+}

contracts/royalty-enforcement/RoyaltyEnforced.sol

@@ -7,7 +7,13 @@ import "./IRoyaltyAllowlist.sol";
 // Access Control
 import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
 
-abstract contract RoyaltyEnforced is AccessControlEnumerable {
+// Errors
+import {RoyaltyEnforcementErrors} from "../errors/Errors.sol";
+
+abstract contract RoyaltyEnforced is
+    AccessControlEnumerable,
+    RoyaltyEnforcementErrors
+{
     ///     =====     Errors         =====
 
     /// @dev Error thrown when calling address is not Allowlisted
@@ -50,12 +56,13 @@ abstract contract RoyaltyEnforced is AccessControlEnumerable {
     function setRoyaltyAllowlistRegistry(
         address _royaltyAllowlist
     ) public onlyRole(DEFAULT_ADMIN_ROLE) {
-        require(
-            IERC165(_royaltyAllowlist).supportsInterface(
+        if (
+            !IERC165(_royaltyAllowlist).supportsInterface(
                 type(IRoyaltyAllowlist).interfaceId
-            ),
-            "contract does not implement IRoyaltyAllowlist"
-        );
+            )
+        ) {
+            revert RoyaltyEnforcementDoesNotImplementRequiredInterface();
+        }
 
         emit RoyaltyAllowlistRegistryUpdated(
             address(royaltyAllowlist),

contracts/token/erc721/abstract/ImmutableERC721Base.sol

@@ -12,6 +12,9 @@ import "../../../royalty-enforcement/RoyaltyEnforced.sol";
 // Utils
 import "@openzeppelin/contracts/utils/Counters.sol";
 
+// Errors
+import {IImmutableERC721Errors} from "../../../errors/Errors.sol";
+
 /*
     ImmutableERC721Base is an abstract contract that offers minimum preset functionality without
     an opinionated form of minting. This contract is intended to be inherited and implement it's
@@ -21,7 +24,8 @@ import "@openzeppelin/contracts/utils/Counters.sol";
 abstract contract ImmutableERC721Base is
     RoyaltyEnforced,
     ERC721Burnable,
-    ERC2981
+    ERC2981,
+    IImmutableERC721Errors
 {
     ///     =====   State Variables  =====
 
@@ -206,7 +210,9 @@ abstract contract ImmutableERC721Base is
 
     /// @dev mints specified token ids to specified address
     function _batchMint(IDMint memory mintRequest) internal {
-        require(mintRequest.to != address(0), "Address is zero");
+        if (mintRequest.to != address(0)) {
+            revert IImmutableERC721SendingToZerothAddress();
+        }
         for (uint256 j = 0; j < mintRequest.tokenIds.length; j++) {
             _mint(mintRequest.to, mintRequest.tokenIds[j]);
         }
@@ -215,7 +221,9 @@ abstract contract ImmutableERC721Base is
 
     /// @dev mints specified token ids to specified address
     function _safeBatchMint(IDMint memory mintRequest) internal {
-        require(mintRequest.to != address(0), "Address is zero");
+        if (mintRequest.to == address(0)) {
+            revert IImmutableERC721SendingToZerothAddress();
+        }
         for (uint256 j; j < mintRequest.tokenIds.length; j++) {
             _safeMint(mintRequest.to, mintRequest.tokenIds[j]);
         }
@@ -225,15 +233,15 @@ abstract contract ImmutableERC721Base is
     /// @dev mints specified token id to specified address
     function _mint(address to, uint256 tokenId) internal override(ERC721) {
         if (_burnedTokens[tokenId]) {
-            revert("ERC721: token already burned");
+            revert IImmutableERC721TokenAlreadyBurned(tokenId);
         }
         super._mint(to, tokenId);
     }
 
     /// @dev mints specified token id to specified address
     function _safeMint(address to, uint256 tokenId) internal override(ERC721) {
         if (_burnedTokens[tokenId]) {
-            revert("ERC721: token already burned");
+            revert IImmutableERC721TokenAlreadyBurned(tokenId);
         }
         super._safeMint(to, tokenId);
     }

contracts/token/erc721/preset/ImmutableERC721PermissionedMintable.sol

@@ -108,7 +108,7 @@ contract ImmutableERC721PermissionedMintable is ImmutableERC721Base {
     /// @dev Allows owner or operator to transfer a batch of tokens
     function safeTransferFromBatch(TransferRequest calldata tr) external {
         if (tr.tokenIds.length != tr.tos.length) {
-            revert("number of token ids not the same as number of receivers");
+            revert IImmutableERC721MismatchedTransferLengths();
         }
 
         for (uint i = 0; i < tr.tokenIds.length; i++) {

test/royalty-enforcement/AllowlistERC721TransfersApprovals.test.ts

@@ -74,7 +74,9 @@ describe("Allowlisted ERC721 Transfers", function () {
 
       await expect(
         erc721.connect(owner).setRoyaltyAllowlistRegistry(erc721Two.address)
-      ).to.be.revertedWith("contract does not implement IRoyaltyAllowlist");
+      ).to.be.revertedWith(
+        "RoyaltyEnforcementDoesNotImplementRequiredInterface()"
+      );
     });
 
     it("Should not allow a non-admin to access the function to update the registry", async function () {

test/token/erc721/ImmutableERC721PermissionedMintable.test.ts

@@ -131,7 +131,7 @@ describe("Immutable ERC721 Permissioned Mintable Test Cases", function () {
       const mintRequests = [{ to: user.address, tokenIds: [1, 2] }];
       await expect(
         erc721.connect(minter).safeMintBatch(mintRequests)
-      ).to.be.revertedWith("ERC721: token already burned");
+      ).to.be.revertedWith("IImmutableERC721TokenAlreadyBurned(1)");
     });
   });