@bananapus/721-hook-v6 0.0.41 → 0.0.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/721-hook-v6",
-  "version": "0.0.41",
+  "version": "0.0.42",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/JB721TiersHookStore.sol

@@ -725,9 +725,6 @@ contract JB721TiersHookStore is IJB721TiersHookStore {
                 || reserveBeneficiaryOf({hook: hook, tierId: tierId}) == address(0)
         ) return 0;
 
-        // A sold-out tier cannot have mintable pending reserves — minting would underflow remainingSupply.
-        if (storedTier.remainingSupply == 0) return 0;
-
         // The number of reserve NFTs which have already been minted from the tier.
         uint256 numberOfReserveMints = numberOfReservesMintedFor[hook][tierId];
 
@@ -1232,7 +1229,7 @@ contract JB721TiersHookStore is IJB721TiersHookStore {
             if (storedTier.remainingSupply == 0) revert JB721TiersHookStore_InsufficientSupplyRemaining(tierId);
 
             // Mint the 721 — decrement remaining supply first so the reserve check below
-            // sees the post-mint state (this non-reserve mint may increase pending reserves).
+            // sees the correct post-mint non-reserve-mint count.
             unchecked {
                 // Keep a reference to its token ID.
                 tokenIds[i] = _generateTokenId({

package/test/TestVotingUnitsLifecycle.t.sol

@@ -275,15 +275,15 @@ contract TestVotingUnitsLifecycle is UnitTestSetup {
                 address(testHook),
                 2,
                 JBStored721Tier({
-                    price: uint104(20),
-                    remainingSupply: uint32(100),
-                    initialSupply: uint32(100),
-                    reserveFrequency: uint16(0),
-                    category: uint24(100),
-                    discountPercent: uint8(0),
-                    packedBools: testHook.test_store().ForTest_packBools(true, false, false, false, false, false),
-                    splitPercent: 0
-                })
+                price: uint104(20),
+                remainingSupply: uint32(100),
+                initialSupply: uint32(100),
+                reserveFrequency: uint16(0),
+                category: uint24(100),
+                discountPercent: uint8(0),
+                packedBools: testHook.test_store().ForTest_packBools(true, false, false, false, false, false),
+                splitPercent: 0
+            })
             );
         // Clear tier 2's custom voting units (so it falls back to price).
         testHook.test_store().ForTest_setTierVotingUnits(address(testHook), 2, 0);

package/test/audit/CodexNemesisReserveSellout.t.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+import {Test} from "forge-std/Test.sol";
+import {JBSplit} from "@bananapus/core-v6/src/structs/JBSplit.sol";
+
+import {JB721TiersHookStore} from "../../src/JB721TiersHookStore.sol";
+import {JB721Tier} from "../../src/structs/JB721Tier.sol";
+import {JB721TierConfig} from "../../src/structs/JB721TierConfig.sol";
+import {JB721TierConfigFlags} from "../../src/structs/JB721TierConfigFlags.sol";
+
+contract CodexNemesisReserveSellout is Test {
+    JB721TiersHookStore internal store;
+
+    function setUp() public {
+        store = new JB721TiersHookStore();
+    }
+
+    /// @notice Verifies that a paid mint cannot consume the last slot when it is reserved.
+    /// @dev Previously this test demonstrated the bug (paid mint succeeded). Now it confirms the fix.
+    function test_paidMintCannotConsumeReservedFinalSlot() public {
+        JB721TierConfig[] memory tiers = new JB721TierConfig[](1);
+        tiers[0] = JB721TierConfig({
+            price: 1 ether,
+            initialSupply: 2,
+            votingUnits: 0,
+            reserveFrequency: 1,
+            reserveBeneficiary: address(0xBEEF),
+            encodedIPFSUri: bytes32(0),
+            category: 0,
+            discountPercent: 0,
+            flags: JB721TierConfigFlags({
+                allowOwnerMint: false,
+                useReserveBeneficiaryAsDefault: false,
+                transfersPausable: false,
+                useVotingUnits: false,
+                cantBeRemoved: false,
+                cantIncreaseDiscountPercent: false,
+                cantBuyWithCredits: false
+            }),
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+
+        store.recordAddTiers(tiers);
+
+        uint16[] memory tierIds = new uint16[](1);
+        tierIds[0] = 1;
+
+        store.recordMint({amount: 1 ether, tierIds: tierIds, isOwnerMint: false});
+
+        JB721Tier memory tier = store.tierOf(address(this), 1, false);
+        assertEq(tier.remainingSupply, 1, "one paid mint leaves one slot");
+        assertEq(store.numberOfPendingReservesFor(address(this), 1), 1, "one reserve is pending");
+
+        // With the fix, the second paid mint reverts because the remaining slot is reserved.
+        vm.expectRevert(
+            abi.encodeWithSelector(JB721TiersHookStore.JB721TiersHookStore_InsufficientSupplyRemaining.selector, 1)
+        );
+        store.recordMint({amount: 1 ether, tierIds: tierIds, isOwnerMint: false});
+
+        // Reserve beneficiary can still claim their entitled mint.
+        store.recordMintReservesFor({tierId: 1, count: 1});
+        assertEq(store.numberOfReservesMintedFor(address(this), 1), 1, "reserve beneficiary got their token");
+    }
+}

package/test/audit/ReserveSlotProtection.t.sol

@@ -0,0 +1,273 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+import {Test} from "forge-std/Test.sol";
+import {JBSplit} from "@bananapus/core-v6/src/structs/JBSplit.sol";
+
+import {JB721TiersHookStore} from "../../src/JB721TiersHookStore.sol";
+import {JB721Tier} from "../../src/structs/JB721Tier.sol";
+import {JB721TierConfig} from "../../src/structs/JB721TierConfig.sol";
+import {JB721TierConfigFlags} from "../../src/structs/JB721TierConfigFlags.sol";
+
+/// @notice Tests that paid mints cannot consume slots reserved for the reserve beneficiary.
+/// @dev Regression test for the vulnerability where `_numberOfPendingReservesFor` returns 0
+/// when `remainingSupply == 0` (sold-out early-return), allowing the post-decrement guard
+/// `0 < 0` to pass and permanently stealing reserved slots from the beneficiary.
+/// The fix uses `_numberOfPendingReservesForMintGuard` which omits the sold-out early-return.
+contract ReserveSlotProtection is Test {
+    JB721TiersHookStore internal store;
+
+    function setUp() public {
+        store = new JB721TiersHookStore();
+    }
+
+    /// @notice Proves the fix: a paid mint that would consume the last reserved slot reverts.
+    /// Scenario: tier with initialSupply=2, reserveFrequency=1 (1 reserve per paid mint).
+    /// After 1 paid mint, 1 slot remains but it's reserved. Second paid mint must revert.
+    /// Post-decrement trace: remaining goes 2->1, pending=ceil(1/1)=1, check 1<1 = false -> ok.
+    /// Second mint: remaining goes 1->0, _numberOfPendingReservesForMintGuard returns 2
+    /// (ceil(2/1)-0=2), check 0<2 -> true -> reverts.
+    function test_paidMintRevertsWhenOnlyReservedSlotsRemain() public {
+        JB721TierConfig[] memory tiers = new JB721TierConfig[](1);
+        tiers[0] = JB721TierConfig({
+            price: 1 ether,
+            initialSupply: 2,
+            votingUnits: 0,
+            reserveFrequency: 1,
+            reserveBeneficiary: address(0xBEEF),
+            encodedIPFSUri: bytes32(0),
+            category: 0,
+            discountPercent: 0,
+            flags: JB721TierConfigFlags({
+                allowOwnerMint: false,
+                useReserveBeneficiaryAsDefault: false,
+                transfersPausable: false,
+                useVotingUnits: false,
+                cantBeRemoved: false,
+                cantIncreaseDiscountPercent: false,
+                cantBuyWithCredits: false
+            }),
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+
+        store.recordAddTiers(tiers);
+
+        uint16[] memory tierIds = new uint16[](1);
+        tierIds[0] = 1;
+
+        // First paid mint succeeds — uses 1 of 2 slots, leaving 1 for the pending reserve.
+        store.recordMint({amount: 1 ether, tierIds: tierIds, isOwnerMint: false});
+
+        // Verify state: 1 remaining supply, 1 pending reserve.
+        JB721Tier memory tier = store.tierOf(address(this), 1, false);
+        assertEq(tier.remainingSupply, 1, "should have 1 slot remaining after first mint");
+        assertEq(store.numberOfPendingReservesFor(address(this), 1), 1, "should have 1 pending reserve");
+
+        // Second paid mint MUST revert — the only remaining slot belongs to the reserve beneficiary.
+        vm.expectRevert(
+            abi.encodeWithSelector(JB721TiersHookStore.JB721TiersHookStore_InsufficientSupplyRemaining.selector, 1)
+        );
+        store.recordMint({amount: 1 ether, tierIds: tierIds, isOwnerMint: false});
+    }
+
+    /// @notice Proves that the reserve beneficiary can still mint their reserved slot after fix.
+    function test_reserveBeneficiaryCanMintAfterPaidSlotsExhausted() public {
+        JB721TierConfig[] memory tiers = new JB721TierConfig[](1);
+        tiers[0] = JB721TierConfig({
+            price: 1 ether,
+            initialSupply: 2,
+            votingUnits: 0,
+            reserveFrequency: 1,
+            reserveBeneficiary: address(0xBEEF),
+            encodedIPFSUri: bytes32(0),
+            category: 0,
+            discountPercent: 0,
+            flags: JB721TierConfigFlags({
+                allowOwnerMint: false,
+                useReserveBeneficiaryAsDefault: false,
+                transfersPausable: false,
+                useVotingUnits: false,
+                cantBeRemoved: false,
+                cantIncreaseDiscountPercent: false,
+                cantBuyWithCredits: false
+            }),
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+
+        store.recordAddTiers(tiers);
+
+        uint16[] memory tierIds = new uint16[](1);
+        tierIds[0] = 1;
+
+        // First paid mint.
+        store.recordMint({amount: 1 ether, tierIds: tierIds, isOwnerMint: false});
+
+        // Reserve beneficiary mints their entitled reserve.
+        uint256[] memory reserveTokenIds = store.recordMintReservesFor({tierId: 1, count: 1});
+        assertEq(reserveTokenIds.length, 1, "reserve beneficiary should get 1 token");
+
+        // After reserve mint, remaining supply is 0 and reserves are fulfilled.
+        JB721Tier memory tier = store.tierOf(address(this), 1, false);
+        assertEq(tier.remainingSupply, 0, "tier should be fully minted");
+        assertEq(store.numberOfReservesMintedFor(address(this), 1), 1, "1 reserve should be minted");
+    }
+
+    /// @notice Tests a larger tier: initialSupply=10, reserveFrequency=2.
+    /// With frequency=2, every 2 paid mints earn 1 reserve (rounded up).
+    /// Post-decrement analysis for the 7th mint:
+    ///   remaining goes 4->3, nonReserveMints=7, pending=ceil(7/2)-0=4.
+    ///   Check: 3 < 4 -> true -> reverts. Correct!
+    /// So mints 1-6 succeed, mint 7 reverts.
+    function test_largerTierReserveProtection() public {
+        JB721TierConfig[] memory tiers = new JB721TierConfig[](1);
+        tiers[0] = JB721TierConfig({
+            price: 0.1 ether,
+            initialSupply: 10,
+            votingUnits: 0,
+            reserveFrequency: 2,
+            reserveBeneficiary: address(0xCAFE),
+            encodedIPFSUri: bytes32(0),
+            category: 0,
+            discountPercent: 0,
+            flags: JB721TierConfigFlags({
+                allowOwnerMint: false,
+                useReserveBeneficiaryAsDefault: false,
+                transfersPausable: false,
+                useVotingUnits: false,
+                cantBeRemoved: false,
+                cantIncreaseDiscountPercent: false,
+                cantBuyWithCredits: false
+            }),
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+
+        store.recordAddTiers(tiers);
+
+        uint16[] memory tierIds = new uint16[](1);
+        tierIds[0] = 1;
+
+        // Mint 6 paid NFTs. After 6 mints: remaining=4, pending=ceil(6/2)=3.
+        for (uint256 i; i < 6; i++) {
+            store.recordMint({amount: 0.1 ether, tierIds: tierIds, isOwnerMint: false});
+        }
+
+        JB721Tier memory tier = store.tierOf(address(this), 1, false);
+        assertEq(tier.remainingSupply, 4, "should have 4 remaining after 6 mints");
+        assertEq(store.numberOfPendingReservesFor(address(this), 1), 3, "should have 3 pending reserves");
+
+        // 7th paid mint should revert: after decrement, remaining=3, pending=ceil(7/2)=4. 3<4 -> reverts.
+        vm.expectRevert(
+            abi.encodeWithSelector(JB721TiersHookStore.JB721TiersHookStore_InsufficientSupplyRemaining.selector, 1)
+        );
+        store.recordMint({amount: 0.1 ether, tierIds: tierIds, isOwnerMint: false});
+    }
+
+    /// @notice Verifies that when reserves are minted between paid mints, paid mints can continue.
+    /// initialSupply=4, reserveFrequency=1.
+    function test_paidMintsResumeAfterReservesMinted() public {
+        JB721TierConfig[] memory tiers = new JB721TierConfig[](1);
+        tiers[0] = JB721TierConfig({
+            price: 1 ether,
+            initialSupply: 4,
+            votingUnits: 0,
+            reserveFrequency: 1,
+            reserveBeneficiary: address(0xBEEF),
+            encodedIPFSUri: bytes32(0),
+            category: 0,
+            discountPercent: 0,
+            flags: JB721TierConfigFlags({
+                allowOwnerMint: false,
+                useReserveBeneficiaryAsDefault: false,
+                transfersPausable: false,
+                useVotingUnits: false,
+                cantBeRemoved: false,
+                cantIncreaseDiscountPercent: false,
+                cantBuyWithCredits: false
+            }),
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+
+        store.recordAddTiers(tiers);
+
+        uint16[] memory tierIds = new uint16[](1);
+        tierIds[0] = 1;
+
+        // Paid mint 1: remaining 4->3, nonReserveMints=1, pending=ceil(1/1)=1. Check: 3<1? No. OK.
+        store.recordMint({amount: 1 ether, tierIds: tierIds, isOwnerMint: false});
+
+        // Paid mint 2: remaining 3->2, nonReserveMints=2, pending=ceil(2/1)=2. Check: 2<2? No. OK.
+        store.recordMint({amount: 1 ether, tierIds: tierIds, isOwnerMint: false});
+
+        // Paid mint 3: remaining 2->1, nonReserveMints=3, pending=ceil(3/1)=3. Check: 1<3? Yes! Revert.
+        vm.expectRevert(
+            abi.encodeWithSelector(JB721TiersHookStore.JB721TiersHookStore_InsufficientSupplyRemaining.selector, 1)
+        );
+        store.recordMint({amount: 1 ether, tierIds: tierIds, isOwnerMint: false});
+
+        // Mint 1 reserve — frees up a slot. Now reservesMinted=1.
+        store.recordMintReservesFor({tierId: 1, count: 1});
+
+        // State: remaining=1, reservesMinted=1, nonReserveMints=2.
+        // Paid mint attempt: remaining 1->0, nonReserveMints=3, pending=ceil(3/1)-1=2. Check: 0<2? Yes! Revert.
+        vm.expectRevert(
+            abi.encodeWithSelector(JB721TiersHookStore.JB721TiersHookStore_InsufficientSupplyRemaining.selector, 1)
+        );
+        store.recordMint({amount: 1 ether, tierIds: tierIds, isOwnerMint: false});
+
+        // Mint remaining reserve.
+        store.recordMintReservesFor({tierId: 1, count: 1});
+
+        // Tier fully minted — 0 remaining.
+        JB721Tier memory tier = store.tierOf(address(this), 1, false);
+        assertEq(tier.remainingSupply, 0, "tier should be fully minted");
+    }
+
+    /// @notice Without reserves, all NFTs in a tier should be mintable (no off-by-one).
+    function test_noReservesFullSupplyMintable() public {
+        JB721TierConfig[] memory tiers = new JB721TierConfig[](1);
+        tiers[0] = JB721TierConfig({
+            price: 0.1 ether,
+            initialSupply: 5,
+            votingUnits: 0,
+            reserveFrequency: 0,
+            reserveBeneficiary: address(0),
+            encodedIPFSUri: bytes32(0),
+            category: 0,
+            discountPercent: 0,
+            flags: JB721TierConfigFlags({
+                allowOwnerMint: false,
+                useReserveBeneficiaryAsDefault: false,
+                transfersPausable: false,
+                useVotingUnits: false,
+                cantBeRemoved: false,
+                cantIncreaseDiscountPercent: false,
+                cantBuyWithCredits: false
+            }),
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+
+        store.recordAddTiers(tiers);
+
+        uint16[] memory tierIds = new uint16[](1);
+        tierIds[0] = 1;
+
+        // Mint all 5 — should succeed since no reserves to protect.
+        for (uint256 i; i < 5; i++) {
+            store.recordMint({amount: 0.1 ether, tierIds: tierIds, isOwnerMint: false});
+        }
+
+        JB721Tier memory tier = store.tierOf(address(this), 1, false);
+        assertEq(tier.remainingSupply, 0, "fully minted");
+
+        // 6th mint should revert (supply exhausted).
+        vm.expectRevert(
+            abi.encodeWithSelector(JB721TiersHookStore.JB721TiersHookStore_InsufficientSupplyRemaining.selector, 1)
+        );
+        store.recordMint({amount: 0.1 ether, tierIds: tierIds, isOwnerMint: false});
+    }
+}

package/test/unit/getters_constructor_Unit.t.sol

@@ -181,15 +181,15 @@ contract Test_Getters_Constructor_Unit is UnitTestSetup {
                     address(hook),
                     i + 1,
                     JBStored721Tier({
-                        price: uint104((i + 1) * 10),
-                        remainingSupply: uint32(100 - (i + 1)),
-                        initialSupply: uint32(100),
-                        reserveFrequency: uint16(0),
-                        category: uint24(100),
-                        discountPercent: uint8(0),
-                        packedBools: hook.test_store().ForTest_packBools(false, false, false, false, false, false),
-                        splitPercent: 0
-                    })
+                    price: uint104((i + 1) * 10),
+                    remainingSupply: uint32(100 - (i + 1)),
+                    initialSupply: uint32(100),
+                    reserveFrequency: uint16(0),
+                    category: uint24(100),
+                    discountPercent: uint8(0),
+                    packedBools: hook.test_store().ForTest_packBools(false, false, false, false, false, false),
+                    splitPercent: 0
+                })
                 );
         }
 
@@ -235,18 +235,18 @@ contract Test_Getters_Constructor_Unit is UnitTestSetup {
                     address(hook),
                     i + 1,
                     JBStored721Tier({
-                        price: uint104((i + 1) * 10),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        remainingSupply: uint32(initialSupply - totalMinted),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        initialSupply: uint32(initialSupply),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        reserveFrequency: uint16(reserveFrequency),
-                        category: uint24(100),
-                        discountPercent: uint8(0),
-                        packedBools: hook.test_store().ForTest_packBools(false, false, false, false, false, false),
-                        splitPercent: 0
-                    })
+                    price: uint104((i + 1) * 10),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    remainingSupply: uint32(initialSupply - totalMinted),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    initialSupply: uint32(initialSupply),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    reserveFrequency: uint16(reserveFrequency),
+                    category: uint24(100),
+                    discountPercent: uint8(0),
+                    packedBools: hook.test_store().ForTest_packBools(false, false, false, false, false, false),
+                    splitPercent: 0
+                })
                 );
             // Manually set the number of reserve mints for each tier.
             hook.test_store().ForTest_setReservesMintedFor(address(hook), i + 1, reservedMinted);
@@ -280,15 +280,15 @@ contract Test_Getters_Constructor_Unit is UnitTestSetup {
                 address(hook),
                 1,
                 JBStored721Tier({
-                    price: uint104(10),
-                    remainingSupply: uint32(10),
-                    initialSupply: uint32(20),
-                    reserveFrequency: uint16(100),
-                    category: uint24(100),
-                    discountPercent: uint8(0),
-                    packedBools: hook.test_store().ForTest_packBools(false, false, true, false, false, false),
-                    splitPercent: 0
-                })
+                price: uint104(10),
+                remainingSupply: uint32(10),
+                initialSupply: uint32(20),
+                reserveFrequency: uint16(100),
+                category: uint24(100),
+                discountPercent: uint8(0),
+                packedBools: hook.test_store().ForTest_packBools(false, false, true, false, false, false),
+                splitPercent: 0
+            })
             );
         // Clear the voting units mapping for tier 1 (ForTest_setTier only overwrites the packed struct).
         hook.test_store().ForTest_setTierVotingUnits(address(hook), 1, 0);
@@ -438,18 +438,18 @@ contract Test_Getters_Constructor_Unit is UnitTestSetup {
                     address(hook),
                     i,
                     JBStored721Tier({
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        price: uint104(i * 10),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        remainingSupply: uint32(10 * i - 5 * i),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        initialSupply: uint32(10 * i),
-                        reserveFrequency: uint16(0),
-                        category: uint24(100),
-                        discountPercent: uint8(0),
-                        packedBools: hook.test_store().ForTest_packBools(false, false, false, false, false, false),
-                        splitPercent: 0
-                    })
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    price: uint104(i * 10),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    remainingSupply: uint32(10 * i - 5 * i),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    initialSupply: uint32(10 * i),
+                    reserveFrequency: uint16(0),
+                    category: uint24(100),
+                    discountPercent: uint8(0),
+                    packedBools: hook.test_store().ForTest_packBools(false, false, false, false, false, false),
+                    splitPercent: 0
+                })
                 );
             // Calculate the theoretical weight for the current tier. 10 the price multiplier.
             theoreticalWeight += (10 * i - 5 * i) * i * 10;

package/test/unit/mintFor_mintReservesFor_Unit.t.sol

@@ -27,18 +27,18 @@ contract Test_mintFor_mintReservesFor_Unit is UnitTestSetup {
                     address(hook),
                     i + 1,
                     JBStored721Tier({
-                        price: uint104((i + 1) * 10),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        remainingSupply: uint32(initialSupply - totalMinted),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        initialSupply: uint32(initialSupply),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        reserveFrequency: uint16(reserveFrequency),
-                        category: uint24(100),
-                        discountPercent: uint8(0),
-                        packedBools: hook.test_store().ForTest_packBools(false, false, true, false, false, false),
-                        splitPercent: 0
-                    })
+                    price: uint104((i + 1) * 10),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    remainingSupply: uint32(initialSupply - totalMinted),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    initialSupply: uint32(initialSupply),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    reserveFrequency: uint16(reserveFrequency),
+                    category: uint24(100),
+                    discountPercent: uint8(0),
+                    packedBools: hook.test_store().ForTest_packBools(false, false, true, false, false, false),
+                    splitPercent: 0
+                })
                 );
             hook.test_store().ForTest_setReservesMintedFor(address(hook), i + 1, reservedMinted);
         }
@@ -77,18 +77,18 @@ contract Test_mintFor_mintReservesFor_Unit is UnitTestSetup {
                 address(hook),
                 1,
                 JBStored721Tier({
-                    price: uint104(10),
-                    // forge-lint: disable-next-line(unsafe-typecast)
-                    remainingSupply: uint32(initialSupply),
-                    // forge-lint: disable-next-line(unsafe-typecast)
-                    initialSupply: uint32(initialSupply),
-                    // forge-lint: disable-next-line(unsafe-typecast)
-                    reserveFrequency: uint16(reserveFrequency),
-                    category: uint24(100),
-                    discountPercent: uint8(0),
-                    packedBools: hook.test_store().ForTest_packBools(true, false, true, false, false, false),
-                    splitPercent: 0
-                })
+                price: uint104(10),
+                // forge-lint: disable-next-line(unsafe-typecast)
+                remainingSupply: uint32(initialSupply),
+                // forge-lint: disable-next-line(unsafe-typecast)
+                initialSupply: uint32(initialSupply),
+                // forge-lint: disable-next-line(unsafe-typecast)
+                reserveFrequency: uint16(reserveFrequency),
+                category: uint24(100),
+                discountPercent: uint8(0),
+                packedBools: hook.test_store().ForTest_packBools(true, false, true, false, false, false),
+                splitPercent: 0
+            })
             );
 
         // Mint the initial tiers.
@@ -184,18 +184,18 @@ contract Test_mintFor_mintReservesFor_Unit is UnitTestSetup {
                     address(hook),
                     i + 1,
                     JBStored721Tier({
-                        price: uint104((i + 1) * 10),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        remainingSupply: uint32(initialSupply - totalMinted),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        initialSupply: uint32(initialSupply),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        reserveFrequency: uint16(reserveFrequency),
-                        category: uint24(100),
-                        discountPercent: uint8(0),
-                        packedBools: hook.test_store().ForTest_packBools(false, false, true, false, false, false),
-                        splitPercent: 0
-                    })
+                    price: uint104((i + 1) * 10),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    remainingSupply: uint32(initialSupply - totalMinted),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    initialSupply: uint32(initialSupply),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    reserveFrequency: uint16(reserveFrequency),
+                    category: uint24(100),
+                    discountPercent: uint8(0),
+                    packedBools: hook.test_store().ForTest_packBools(false, false, true, false, false, false),
+                    splitPercent: 0
+                })
                 );
 
             // Set the number of reserve NFTs already minted for the tier.
@@ -286,18 +286,18 @@ contract Test_mintFor_mintReservesFor_Unit is UnitTestSetup {
                     address(hook),
                     i + 1,
                     JBStored721Tier({
-                        price: uint104((i + 1) * 10),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        remainingSupply: uint32(initialSupply - totalMinted),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        initialSupply: uint32(initialSupply),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        reserveFrequency: uint16(reserveFrequency),
-                        category: uint24(100),
-                        discountPercent: uint8(0),
-                        packedBools: hook.test_store().ForTest_packBools(false, false, true, false, false, false),
-                        splitPercent: 0
-                    })
+                    price: uint104((i + 1) * 10),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    remainingSupply: uint32(initialSupply - totalMinted),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    initialSupply: uint32(initialSupply),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    reserveFrequency: uint16(reserveFrequency),
+                    category: uint24(100),
+                    discountPercent: uint8(0),
+                    packedBools: hook.test_store().ForTest_packBools(false, false, true, false, false, false),
+                    splitPercent: 0
+                })
                 );
             hook.test_store().ForTest_setReservesMintedFor(address(hook), i + 1, reservedMinted);
         }
@@ -327,18 +327,18 @@ contract Test_mintFor_mintReservesFor_Unit is UnitTestSetup {
                     address(hook),
                     i + 1,
                     JBStored721Tier({
-                        price: uint104((i + 1) * 10),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        remainingSupply: uint32(initialSupply - totalMinted),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        initialSupply: uint32(initialSupply),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        reserveFrequency: uint16(reserveFrequency),
-                        category: uint24(100),
-                        discountPercent: uint8(0),
-                        packedBools: hook.test_store().ForTest_packBools(false, false, true, false, false, false),
-                        splitPercent: 0
-                    })
+                    price: uint104((i + 1) * 10),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    remainingSupply: uint32(initialSupply - totalMinted),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    initialSupply: uint32(initialSupply),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    reserveFrequency: uint16(reserveFrequency),
+                    category: uint24(100),
+                    discountPercent: uint8(0),
+                    packedBools: hook.test_store().ForTest_packBools(false, false, true, false, false, false),
+                    splitPercent: 0
+                })
                 );
             hook.test_store().ForTest_setReservesMintedFor(address(hook), i + 1, reservedMinted);
         }

package/test/unit/redeem_Unit.t.sol

@@ -19,18 +19,18 @@ contract Test_cashOut_Unit is UnitTestSetup {
                     address(hook),
                     i,
                     JBStored721Tier({
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        price: uint104(i * 10),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        remainingSupply: uint32(10 * i - 5 * i),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        initialSupply: uint32(10 * i),
-                        reserveFrequency: uint16(0),
-                        category: uint24(100),
-                        discountPercent: uint8(0),
-                        packedBools: hook.test_store().ForTest_packBools(false, false, false, false, false, false),
-                        splitPercent: 0
-                    })
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    price: uint104(i * 10),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    remainingSupply: uint32(10 * i - 5 * i),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    initialSupply: uint32(10 * i),
+                    reserveFrequency: uint16(0),
+                    category: uint24(100),
+                    discountPercent: uint8(0),
+                    packedBools: hook.test_store().ForTest_packBools(false, false, false, false, false, false),
+                    splitPercent: 0
+                })
                 );
             totalWeight += (10 * i - 5 * i) * i * 10;
         }
@@ -94,18 +94,18 @@ contract Test_cashOut_Unit is UnitTestSetup {
                     address(hook),
                     i,
                     JBStored721Tier({
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        price: uint104(i * 10),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        remainingSupply: uint32(10 * i - 5 * i),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        initialSupply: uint32(10 * i),
-                        reserveFrequency: uint16(0),
-                        category: uint24(100),
-                        discountPercent: uint8(0),
-                        packedBools: hook.test_store().ForTest_packBools(false, false, false, false, false, false),
-                        splitPercent: 0
-                    })
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    price: uint104(i * 10),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    remainingSupply: uint32(10 * i - 5 * i),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    initialSupply: uint32(10 * i),
+                    reserveFrequency: uint16(0),
+                    category: uint24(100),
+                    discountPercent: uint8(0),
+                    packedBools: hook.test_store().ForTest_packBools(false, false, false, false, false, false),
+                    splitPercent: 0
+                })
                 );
             totalWeight += (10 * i - 5 * i) * i * 10;
         }
@@ -155,18 +155,18 @@ contract Test_cashOut_Unit is UnitTestSetup {
                     address(hook),
                     i,
                     JBStored721Tier({
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        price: uint104(i * 10),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        remainingSupply: uint32(10 * i - 5 * i),
-                        // forge-lint: disable-next-line(unsafe-typecast)
-                        initialSupply: uint32(10 * i),
-                        reserveFrequency: uint16(0),
-                        category: uint24(100),
-                        discountPercent: uint8(0),
-                        packedBools: hook.test_store().ForTest_packBools(false, false, false, false, false, false),
-                        splitPercent: 0
-                    })
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    price: uint104(i * 10),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    remainingSupply: uint32(10 * i - 5 * i),
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    initialSupply: uint32(10 * i),
+                    reserveFrequency: uint16(0),
+                    category: uint24(100),
+                    discountPercent: uint8(0),
+                    packedBools: hook.test_store().ForTest_packBools(false, false, false, false, false, false),
+                    splitPercent: 0
+                })
                 );
             totalWeight += (10 * i - 5 * i) * i * 10;
         }