fix(licensing-hook): check tot supply b4 set limit

Author: sebsadface

contracts/hooks/TotalLicenseTokenLimitHook.sol

@@ -33,16 +33,27 @@ contract TotalLicenseTokenLimitHook is BaseModule, AccessControlled, ILicensingH
     /// @param totalSupply The total supply of the license tokens
     /// @param amount The amount of license tokens to mint
     /// @param limit The total license token limit
-    error TotalLicenseTokenLimitExceeded(uint256 totalSupply, uint256 amount, uint256 limit);
+    error TotalLicenseTokenLimitHook_TotalLicenseTokenLimitExceeded(uint256 totalSupply, uint256 amount, uint256 limit);
+
+    /// @notice Emitted when the limit is lower than the existing supply
+    /// @param totalSupply The total supply of the license tokens
+    /// @param limit The total license token limit
+    error TotalLicenseTokenLimitHook_LimitLowerThanTotalSupply(uint256 totalSupply, uint256 limit);
+
+    /// @notice Emitted when the license registry is the zero address
+    error TotalLicenseTokenLimitHook_ZeroLicenseRegistry();
+
+    /// @notice Emitted when the license token is the zero address
+    error TotalLicenseTokenLimitHook_ZeroLicenseToken();
 
     constructor(
         address licenseRegistry,
         address licenseToken,
         address accessController,
         address ipAssetRegistry
     ) AccessControlled(accessController, ipAssetRegistry) {
-        require(licenseRegistry != address(0), "TotalLicenseTokenLimitHook: licenseRegistry is the zero address");
-        require(licenseToken != address(0), "TotalLicenseTokenLimitHook: licenseToken is the zero address");
+        if (licenseRegistry == address(0)) revert TotalLicenseTokenLimitHook_ZeroLicenseRegistry();
+        if (licenseToken == address(0)) revert TotalLicenseTokenLimitHook_ZeroLicenseToken();
         LICENSE_REGISTRY = ILicenseRegistry(licenseRegistry);
         LICENSE_TOKEN = ILicenseToken(licenseToken);
     }
@@ -59,6 +70,8 @@ contract TotalLicenseTokenLimitHook is BaseModule, AccessControlled, ILicensingH
         uint256 limit
     ) external verifyPermission(licensorIpId) {
         bytes32 key = keccak256(abi.encodePacked(licensorIpId, licenseTemplate, licenseTermsId));
+        uint256 totalSupply = _getTotalSupply(licensorIpId);
+        if (limit < totalSupply) revert TotalLicenseTokenLimitHook_LimitLowerThanTotalSupply(totalSupply, limit);
         totalLicenseTokenLimit[key] = limit;
         emit SetTotalLicenseTokenLimit(licensorIpId, licenseTemplate, licenseTermsId, limit);
     }
@@ -163,10 +176,9 @@ contract TotalLicenseTokenLimitHook is BaseModule, AccessControlled, ILicensingH
         uint256 limit = totalLicenseTokenLimit[key];
         if (limit != 0) {
             // derivative IPs are also considered as minted license tokens
-            uint256 totalSupply = LICENSE_REGISTRY.getDerivativeIpCount(licensorIpId) +
-                LICENSE_TOKEN.getTotalTokensByLicensor(licensorIpId);
+            uint256 totalSupply = _getTotalSupply(licensorIpId);
             if (totalSupply + amount > limit) {
-                revert TotalLicenseTokenLimitExceeded(totalSupply, amount, limit);
+                revert TotalLicenseTokenLimitHook_TotalLicenseTokenLimitExceeded(totalSupply, amount, limit);
             }
         }
     }
@@ -179,4 +191,9 @@ contract TotalLicenseTokenLimitHook is BaseModule, AccessControlled, ILicensingH
         (, , uint256 mintingFee, ) = ILicenseTemplate(licenseTemplate).getRoyaltyPolicy(licenseTermsId);
         return amount * mintingFee;
     }
+
+    function _getTotalSupply(address licensorIpId) internal view returns (uint256) {
+        return
+            LICENSE_REGISTRY.getDerivativeIpCount(licensorIpId) + LICENSE_TOKEN.getTotalTokensByLicensor(licensorIpId);
+    }
 }

test/hooks/TotalLicenseTokenLimitHook.t.sol

@@ -3,7 +3,6 @@ pragma solidity 0.8.26;
 
 import { PILFlavors } from "@storyprotocol/core/lib/PILFlavors.sol";
 import { Licensing } from "@storyprotocol/core/lib/Licensing.sol";
-import "@storyprotocol/core/lib/Errors.sol";
 
 import { TotalLicenseTokenLimitHook } from "contracts/hooks/TotalLicenseTokenLimitHook.sol";
 
@@ -73,12 +72,22 @@ contract TotalLicenseTokenLimitHookTest is BaseTest {
         licensingModule.mintLicenseTokens(ipId3, address(pilTemplate), socialRemixTermsId, 10, u.alice, "");
 
         vm.expectRevert(
-            abi.encodeWithSelector(TotalLicenseTokenLimitHook.TotalLicenseTokenLimitExceeded.selector, 10, 5, 10)
+            abi.encodeWithSelector(
+                TotalLicenseTokenLimitHook.TotalLicenseTokenLimitHook_TotalLicenseTokenLimitExceeded.selector,
+                10,
+                5,
+                10
+            )
         );
         licensingModule.mintLicenseTokens(ipId1, address(pilTemplate), socialRemixTermsId, 5, u.alice, "");
 
         vm.expectRevert(
-            abi.encodeWithSelector(TotalLicenseTokenLimitHook.TotalLicenseTokenLimitExceeded.selector, 20, 5, 20)
+            abi.encodeWithSelector(
+                TotalLicenseTokenLimitHook.TotalLicenseTokenLimitHook_TotalLicenseTokenLimitExceeded.selector,
+                20,
+                5,
+                20
+            )
         );
         licensingModule.mintLicenseTokens(ipId2, address(pilTemplate), socialRemixTermsId, 5, u.alice, "");
     }
@@ -108,8 +117,50 @@ contract TotalLicenseTokenLimitHookTest is BaseTest {
         vm.stopPrank();
 
         vm.startPrank(ipOwner2);
-        vm.expectRevert(abi.encodeWithSelector(Errors.AccessController__PermissionDenied.selector, ipId1, ipOwner2, address(totalLimitHook), totalLimitHook.setTotalLicenseTokenLimit.selector));
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                Errors.AccessController__PermissionDenied.selector,
+                ipId1,
+                ipOwner2,
+                address(totalLimitHook),
+                totalLimitHook.setTotalLicenseTokenLimit.selector
+            )
+        );
         totalLimitHook.setTotalLicenseTokenLimit(ipId1, address(pilTemplate), socialRemixTermsId, 20);
+    }
 
+    function test_TotalLicenseTokenLimitHook_revert_limitLowerThanTotalSupply_setLimit() public {
+        uint256 socialRemixTermsId = pilTemplate.registerLicenseTerms(PILFlavors.nonCommercialSocialRemixing());
+        TotalLicenseTokenLimitHook totalLimitHook = new TotalLicenseTokenLimitHook(
+            address(licenseRegistry),
+            address(licenseToken),
+            address(accessController),
+            address(ipAssetRegistry)
+        );
+
+        vm.prank(u.admin);
+        moduleRegistry.registerModule("TotalLicenseTokenLimitHook", address(totalLimitHook));
+        Licensing.LicensingConfig memory licensingConfig = Licensing.LicensingConfig({
+            isSet: true,
+            mintingFee: 100,
+            licensingHook: address(totalLimitHook),
+            hookData: ""
+        });
+
+        vm.startPrank(ipOwner1);
+        licensingModule.setLicensingConfig(ipId1, address(pilTemplate), socialRemixTermsId, licensingConfig);
+        totalLimitHook.setTotalLicenseTokenLimit(ipId1, address(pilTemplate), socialRemixTermsId, 10);
+        assertEq(totalLimitHook.getTotalLicenseTokenLimit(ipId1, address(pilTemplate), socialRemixTermsId), 10);
+
+        licensingModule.mintLicenseTokens(ipId1, address(pilTemplate), socialRemixTermsId, 10, u.alice, "");
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                TotalLicenseTokenLimitHook.TotalLicenseTokenLimitHook_LimitLowerThanTotalSupply.selector,
+                10,
+                5
+            )
+        );
+        totalLimitHook.setTotalLicenseTokenLimit(ipId1, address(pilTemplate), socialRemixTermsId, 5);
     }
 }