feat: capped minter v2 nested testing

l2-contracts/src/ZkCappedMinterV2.sol

@@ -3,15 +3,15 @@ pragma solidity 0.8.24;
 
 import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";
 import {Pausable} from "@openzeppelin/contracts/security/Pausable.sol";
-import {IMintableAndDelegatable} from "src/interfaces/IMintableAndDelegatable.sol";
+import {IMintable} from "src/interfaces/IMintable.sol";
 
 /// @title ZkCappedMinterV2
 /// @author [ScopeLift](https://scopelift.co)
 /// @notice A contract to allow a permissioned entity to mint ZK tokens up to a given amount (the cap).
 /// @custom:security-contact [email protected]
 contract ZkCappedMinterV2 is AccessControl, Pausable {
   /// @notice The contract where the tokens will be minted by an authorized minter.
-  IMintableAndDelegatable public immutable TOKEN;
+  IMintable public immutable MINTABLE;
 
   /// @notice The maximum number of tokens that may be minted by the ZkCappedMinter.
   uint256 public immutable CAP;
@@ -53,20 +53,20 @@ contract ZkCappedMinterV2 is AccessControl, Pausable {
   error ZkCappedMinterV2__InvalidTime();
 
   /// @notice Constructor for a new ZkCappedMinterV2 contract
-  /// @param _token The token contract where tokens will be minted.
+  /// @param _mintable The contract where tokens will be minted.
   /// @param _admin The address that will be granted the admin role.
   /// @param _cap The maximum number of tokens that may be minted by the ZkCappedMinter.
   /// @param _startTime The timestamp when minting can begin.
   /// @param _expirationTime The timestamp after which minting is no longer allowed (inclusive).
-  constructor(IMintableAndDelegatable _token, address _admin, uint256 _cap, uint48 _startTime, uint48 _expirationTime) {
+  constructor(IMintable _mintable, address _admin, uint256 _cap, uint48 _startTime, uint48 _expirationTime) {
     if (_startTime > _expirationTime) {
       revert ZkCappedMinterV2__InvalidTime();
     }
     if (_startTime < block.timestamp) {
       revert ZkCappedMinterV2__InvalidTime();
     }
 
-    TOKEN = _token;
+    MINTABLE = _mintable;
     CAP = _cap;
     START_TIME = _startTime;
     EXPIRATION_TIME = _expirationTime;
@@ -102,8 +102,10 @@ contract ZkCappedMinterV2 is AccessControl, Pausable {
     _requireNotPaused();
     _checkRole(MINTER_ROLE, msg.sender);
     _revertIfCapExceeded(_amount);
+
     minted += _amount;
-    TOKEN.mint(_to, _amount);
+
+    MINTABLE.mint(_to, _amount);
   }
 
   /// @notice Reverts if the amount of new tokens will increase the minted tokens beyond the mint cap.

l2-contracts/src/ZkCappedMinterV2Factory.sol

@@ -3,7 +3,7 @@ pragma solidity 0.8.24;
 
 import {L2ContractHelper} from "src/lib/L2ContractHelper.sol";
 import {ZkCappedMinterV2} from "src/ZkCappedMinterV2.sol";
-import {IMintableAndDelegatable} from "src/interfaces/IMintableAndDelegatable.sol";
+import {IMintable} from "src/interfaces/IMintable.sol";
 
 /// @title ZkCappedMinterV2Factory
 /// @author [ScopeLift](https://scopelift.co)
@@ -19,64 +19,64 @@ contract ZkCappedMinterV2Factory {
 
   /// @notice Emitted when a new ZkCappedMinterV2 is created.
   /// @param minterAddress The address of the newly deployed ZkCappedMinterV2.
-  /// @param token The token contract where tokens will be minted.
+  /// @param mintable The contract where tokens will be minted.
   /// @param admin The address authorized to mint tokens.
   /// @param cap The maximum number of tokens that may be minted.
   /// @param startTime The timestamp when minting can begin.
   /// @param expirationTime The timestamp after which minting is no longer allowed.
   event CappedMinterV2Created(
     address indexed minterAddress,
-    IMintableAndDelegatable token,
+    IMintable mintable,
     address admin,
     uint256 cap,
     uint48 startTime,
     uint48 expirationTime
   );
 
   /// @notice Deploys a new ZkCappedMinterV2 contract using CREATE2.
-  /// @param _token The token contract where tokens will be minted.
+  /// @param _mintable The contract where tokens will be minted.
   /// @param _admin The address authorized to mint tokens.
   /// @param _cap The maximum number of tokens that may be minted.
   /// @param _startTime The timestamp when minting can begin.
   /// @param _expirationTime The timestamp after which minting is no longer allowed.
   /// @param _saltNonce A user-provided nonce for salt calculation.
   /// @return minterAddress The address of the newly deployed ZkCappedMinterV2.
   function createCappedMinter(
-    IMintableAndDelegatable _token,
+    IMintable _mintable,
     address _admin,
     uint256 _cap,
     uint48 _startTime,
     uint48 _expirationTime,
     uint256 _saltNonce
   ) external returns (address minterAddress) {
-    bytes memory saltArgs = abi.encode(_token, _admin, _cap, _startTime, _expirationTime);
+    bytes memory saltArgs = abi.encode(_mintable, _admin, _cap, _startTime, _expirationTime);
     bytes32 salt = _calculateSalt(saltArgs, _saltNonce);
-    ZkCappedMinterV2 instance = new ZkCappedMinterV2{salt: salt}(_token, _admin, _cap, _startTime, _expirationTime);
+    ZkCappedMinterV2 instance = new ZkCappedMinterV2{salt: salt}(_mintable, _admin, _cap, _startTime, _expirationTime);
     minterAddress = address(instance);
 
-    emit CappedMinterV2Created(minterAddress, _token, _admin, _cap, _startTime, _expirationTime);
+    emit CappedMinterV2Created(minterAddress, _mintable, _admin, _cap, _startTime, _expirationTime);
   }
 
   /// @notice Computes the address of a ZkCappedMinterV2 deployed via this factory.
-  /// @param _token The token contract where tokens will be minted.
+  /// @param _mintable The contract where tokens will be minted.
   /// @param _admin The address authorized to mint tokens.
   /// @param _cap The maximum number of tokens that may be minted.
   /// @param _startTime The timestamp when minting can begin.
   /// @param _expirationTime The timestamp after which minting is no longer allowed.
   /// @param _saltNonce The nonce used for salt calculation.
   /// @return addr The address of the ZkCappedMinterV2.
   function getMinter(
-    IMintableAndDelegatable _token,
+    IMintable _mintable,
     address _admin,
     uint256 _cap,
     uint48 _startTime,
     uint48 _expirationTime,
     uint256 _saltNonce
   ) external view returns (address addr) {
-    bytes memory saltArgs = abi.encode(_token, _admin, _cap, _startTime, _expirationTime);
+    bytes memory saltArgs = abi.encode(_mintable, _admin, _cap, _startTime, _expirationTime);
     bytes32 salt = _calculateSalt(saltArgs, _saltNonce);
     addr = L2ContractHelper.computeCreate2Address(
-      address(this), salt, BYTECODE_HASH, keccak256(abi.encode(_token, _admin, _cap, _startTime, _expirationTime))
+      address(this), salt, BYTECODE_HASH, keccak256(abi.encode(_mintable, _admin, _cap, _startTime, _expirationTime))
     );
   }
 

l2-contracts/test/ZkCappedMinterV2.t.sol

@@ -3,7 +3,7 @@ pragma solidity 0.8.24;
 
 import {ZkTokenTest} from "test/utils/ZkTokenTest.sol";
 import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
-import {IMintableAndDelegatable} from "src/interfaces/IMintableAndDelegatable.sol";
+import {IMintable} from "src/interfaces/IMintable.sol";
 import {ZkCappedMinterV2} from "src/ZkCappedMinterV2.sol";
 import {console2} from "forge-std/Test.sol";
 
@@ -21,17 +21,25 @@ contract ZkCappedMinterV2Test is ZkTokenTest {
     DEFAULT_START_TIME = uint48(vm.getBlockTimestamp());
     DEFAULT_EXPIRATION_TIME = uint48(DEFAULT_START_TIME + 3 days);
 
-    cappedMinter = _createCappedMinter(cappedMinterAdmin, DEFAULT_CAP, DEFAULT_START_TIME, DEFAULT_EXPIRATION_TIME);
+    cappedMinter =
+      _createCappedMinter(address(token), cappedMinterAdmin, DEFAULT_CAP, DEFAULT_START_TIME, DEFAULT_EXPIRATION_TIME);
 
+    _grantMinterRoleToCappedMinter(address(cappedMinter));
+  }
+
+  function _grantMinterRoleToCappedMinter(address _cappedMinter) internal {
     vm.prank(admin);
-    token.grantRole(MINTER_ROLE, address(cappedMinter));
+    token.grantRole(MINTER_ROLE, address(_cappedMinter));
   }
 
-  function _createCappedMinter(address _admin, uint256 _cap, uint48 _startTime, uint48 _expirationTime)
-    internal
-    returns (ZkCappedMinterV2)
-  {
-    return new ZkCappedMinterV2(IMintableAndDelegatable(address(token)), _admin, _cap, _startTime, _expirationTime);
+  function _createCappedMinter(
+    address _mintable,
+    address _admin,
+    uint256 _cap,
+    uint48 _startTime,
+    uint48 _expirationTime
+  ) internal returns (ZkCappedMinterV2) {
+    return new ZkCappedMinterV2(IMintable(_mintable), _admin, _cap, _startTime, _expirationTime);
   }
 
   function _boundToValidTimeControls(uint48 _startTime, uint48 _expirationTime) internal view returns (uint48, uint48) {
@@ -69,8 +77,8 @@ contract Constructor is ZkCappedMinterV2Test {
     (_startTime, _expirationTime) = _boundToValidTimeControls(_startTime, _expirationTime);
     vm.warp(_startTime);
 
-    ZkCappedMinterV2 cappedMinter = _createCappedMinter(_admin, _cap, _startTime, _expirationTime);
-    assertEq(address(cappedMinter.TOKEN()), address(token));
+    ZkCappedMinterV2 cappedMinter = _createCappedMinter(address(token), _admin, _cap, _startTime, _expirationTime);
+    assertEq(address(cappedMinter.MINTABLE()), address(token));
     assertEq(cappedMinter.CAP(), _cap);
     assertEq(cappedMinter.START_TIME(), _startTime);
     assertEq(cappedMinter.EXPIRATION_TIME(), _expirationTime);
@@ -85,7 +93,7 @@ contract Constructor is ZkCappedMinterV2Test {
     _startTime = uint48(bound(_startTime, 1, type(uint48).max));
     _invalidExpirationTime = uint48(bound(_invalidExpirationTime, 0, _startTime - 1));
     vm.expectRevert(ZkCappedMinterV2.ZkCappedMinterV2__InvalidTime.selector);
-    _createCappedMinter(_admin, _cap, _startTime, _invalidExpirationTime);
+    _createCappedMinter(address(token), _admin, _cap, _startTime, _invalidExpirationTime);
   }
 
   function testFuzz_RevertIf_StartTimeInPast(address _admin, uint256 _cap, uint48 _startTime, uint48 _expirationTime)
@@ -99,7 +107,7 @@ contract Constructor is ZkCappedMinterV2Test {
     _expirationTime = uint48(bound(_expirationTime, _pastStartTime + 1, type(uint48).max));
 
     vm.expectRevert(ZkCappedMinterV2.ZkCappedMinterV2__InvalidTime.selector);
-    _createCappedMinter(_admin, _cap, _pastStartTime, _expirationTime);
+    _createCappedMinter(address(token), _admin, _cap, _pastStartTime, _expirationTime);
   }
 }
 
@@ -165,6 +173,109 @@ contract Mint is ZkCappedMinterV2Test {
     cappedMinter.mint(_receiver, _amount);
   }
 
+  function testFuzz_NestedMintingContributesToParentCap(
+    address _parentAdmin,
+    address _childAdmin,
+    address _minter,
+    address _receiver,
+    uint256 _parentCap,
+    uint256 _childCap,
+    uint256 _amount1,
+    uint256 _amount2,
+    uint48 _startTime,
+    uint48 _expirationTime
+  ) public {
+    // Setup caps where child cap is less or equal to parent cap
+    _parentCap = bound(_parentCap, 2, DEFAULT_CAP);
+    _childCap = bound(_childCap, 2, _parentCap);
+
+    // Two amounts that together are within child cap
+    uint256 maxAmount = _childCap / 2;
+    _amount1 = bound(_amount1, 1, maxAmount);
+    _amount2 = bound(_amount2, 1, maxAmount);
+
+    vm.assume(_receiver != address(0));
+
+    (_startTime, _expirationTime) = _boundToValidTimeControls(_startTime, _expirationTime);
+    vm.warp(_startTime);
+
+    ZkCappedMinterV2 parentMinter =
+      _createCappedMinter(address(token), _parentAdmin, _parentCap, _startTime, _expirationTime);
+    // Create child minter with parent minter as token
+    ZkCappedMinterV2 childMinter =
+      _createCappedMinter(address(parentMinter), _childAdmin, _childCap, _startTime, _expirationTime);
+
+    _grantMinterRoleToCappedMinter(address(parentMinter));
+
+    // Parent minter grants MINTER_ROLE to child minter
+    _grantMinterRole(parentMinter, _parentAdmin, address(childMinter));
+    // Child minter grants MINTER_ROLE to minter
+    _grantMinterRole(childMinter, _childAdmin, _minter);
+
+    uint256 balanceBefore = token.balanceOf(_receiver);
+
+    // Minter mints through child contract
+    vm.prank(_minter);
+    childMinter.mint(_receiver, _amount1);
+
+    uint256 balanceAfter = token.balanceOf(_receiver);
+
+    // Verify amounts are tracked in both contracts
+    assertEq(childMinter.minted(), _amount1);
+    assertEq(parentMinter.minted(), _amount1);
+    assertEq(balanceAfter, balanceBefore + _amount1);
+
+    // Mint again
+    vm.prank(_minter);
+    childMinter.mint(_receiver, _amount2);
+
+    balanceAfter = token.balanceOf(_receiver);
+
+    // Verify total amounts are tracked in both contracts
+    assertEq(childMinter.minted(), _amount1 + _amount2);
+    assertEq(parentMinter.minted(), _amount1 + _amount2);
+    assertEq(balanceAfter, balanceBefore + _amount1 + _amount2);
+  }
+
+  function testFuzz_ParentMintDoesNotCountAgainstChildCap(
+    address _parentAdmin,
+    address _childAdmin,
+    address _minter,
+    address _receiver,
+    uint256 _parentCap,
+    uint256 _childCap,
+    uint256 _amount,
+    uint48 _startTime,
+    uint48 _expirationTime
+  ) public {
+    vm.assume(_receiver != address(0));
+
+    _parentCap = bound(_parentCap, 1, DEFAULT_CAP);
+    _amount = bound(_amount, 1, _parentCap);
+
+    (_startTime, _expirationTime) = _boundToValidTimeControls(_startTime, _expirationTime);
+    vm.warp(_startTime);
+
+    ZkCappedMinterV2 parentMinter =
+      _createCappedMinter(address(token), _parentAdmin, _parentCap, _startTime, _expirationTime);
+    // Create child minter with parent minter as token
+    ZkCappedMinterV2 childMinter =
+      _createCappedMinter(address(parentMinter), _childAdmin, _childCap, _startTime, _expirationTime);
+
+    _grantMinterRoleToCappedMinter(address(parentMinter));
+
+    // Parent minter grants MINTER_ROLE to minter
+    _grantMinterRole(parentMinter, _parentAdmin, _minter);
+
+    // Minter mints through parent contract
+    vm.prank(_minter);
+    parentMinter.mint(_receiver, _amount);
+
+    // Verify child contract is not affected
+    assertEq(childMinter.minted(), 0);
+    assertEq(parentMinter.minted(), _amount);
+  }
+
   function testFuzz_RevertIf_MintAttemptedByNonMinter(address _nonMinter, uint256 _amount) public {
     _amount = bound(_amount, 1, DEFAULT_CAP);
 
@@ -230,6 +341,49 @@ contract Mint is ZkCappedMinterV2Test {
     vm.prank(_minter);
     cappedMinter.mint(_receiver, _amount);
   }
+
+  function testFuzz_RevertIf_ChildExceedsParentMintEvenThoughChildCapIsHigher(
+    address _parentAdmin,
+    address _childAdmin,
+    address _minter,
+    address _receiver,
+    uint256 _parentCap,
+    uint256 _childCap,
+    uint256 _amount,
+    uint48 _startTime,
+    uint48 _expirationTime
+  ) public {
+    // Parent has lower cap than child
+    _parentCap = bound(_parentCap, 2, MAX_MINT_SUPPLY - 1);
+    _childCap = bound(_childCap, _parentCap + 1, MAX_MINT_SUPPLY);
+    // Amount exceeds parent cap but is within child cap
+    _amount = bound(_amount, _parentCap + 1, _childCap);
+
+    vm.assume(_parentAdmin != address(0));
+    vm.assume(_childAdmin != address(0));
+    vm.assume(_minter != address(0));
+    vm.assume(_receiver != address(0));
+    vm.assume(_receiver != initMintReceiver);
+
+    (_startTime, _expirationTime) = _boundToValidTimeControls(_startTime, _expirationTime);
+    vm.warp(_startTime);
+
+    ZkCappedMinterV2 parentMinter =
+      _createCappedMinter(address(token), _parentAdmin, _parentCap, _startTime, _expirationTime);
+    ZkCappedMinterV2 childMinter =
+      _createCappedMinter(address(parentMinter), _childAdmin, _childCap, _startTime, _expirationTime);
+
+    // Parent minter grants MINTER_ROLE to child minter
+    _grantMinterRole(parentMinter, _parentAdmin, address(childMinter));
+
+    // Child tries to mint more than parent's cap
+    vm.startPrank(address(childMinter));
+    vm.expectRevert(
+      abi.encodeWithSelector(ZkCappedMinterV2.ZkCappedMinterV2__CapExceeded.selector, address(childMinter), _amount)
+    );
+    parentMinter.mint(_receiver, _amount);
+    vm.stopPrank();
+  }
 }
 
 contract Pause is ZkCappedMinterV2Test {
@@ -342,7 +496,7 @@ contract SetMetadataURI is ZkCappedMinterV2Test {
   {
     (_startTime, _expirationTime) = _boundToValidTimeControls(_startTime, _expirationTime);
 
-    ZkCappedMinterV2 cappedMinter = _createCappedMinter(_admin, _cap, _startTime, _expirationTime);
+    ZkCappedMinterV2 cappedMinter = _createCappedMinter(address(token), _admin, _cap, _startTime, _expirationTime);
     assertEq(cappedMinter.metadataURI(), bytes32(0));
   }