@bananapus/721-hook-v6 0.0.40 → 0.0.42

package/test/audit/{20260425CodexNemesisReserveActivation.t.sol → ReserveActivation.t.sol}

@@ -9,14 +9,17 @@ import {JB721Tier} from "../../src/structs/JB721Tier.sol";
 import {JB721TierConfig} from "../../src/structs/JB721TierConfig.sol";
 import {JB721TierConfigFlags} from "../../src/structs/JB721TierConfigFlags.sol";
 
-contract Test_20260425CodexNemesisReserveActivation is Test {
+contract Test_ReserveActivation is Test {
     JB721TiersHookStore internal store;
 
     function setUp() external {
         store = new JB721TiersHookStore();
     }
 
-    function test_retroactiveDefaultReserveBeneficiaryCreatesUnmintablePendingReserves() external {
+    /// @notice Creating a tier with reserveFrequency > 0 and no beneficiary (tier-specific or default)
+    /// is now rejected at creation time. This prevents the phantom-reserves scenario entirely.
+    function test_soldOutTier_noPhantomReserves_afterDefaultBeneficiaryChange() external {
+        // Attempt to add a tier with reserve frequency but no beneficiary — should revert.
         JB721TierConfig[] memory initialTiers = new JB721TierConfig[](1);
         initialTiers[0] = _tier({
             price: 1,
@@ -26,40 +29,31 @@ contract Test_20260425CodexNemesisReserveActivation is Test {
             useReserveBeneficiaryAsDefault: false,
             category: 1
         });
-        store.recordAddTiers(initialTiers);
-
-        uint16[] memory tierIds = new uint16[](10);
-        for (uint256 i; i < tierIds.length; i++) {
-            tierIds[i] = 1;
-        }
-        store.recordMint({amount: 10, tierIds: tierIds, isOwnerMint: false});
 
-        JB721Tier memory beforeDefault = store.tierOf({hook: address(this), id: 1, includeResolvedUri: false});
-        assertEq(beforeDefault.remainingSupply, 0);
-        assertEq(beforeDefault.reserveFrequency, 0);
-        assertEq(store.numberOfPendingReservesFor({hook: address(this), tierId: 1}), 0);
-        assertEq(store.totalCashOutWeight(address(this)), 10);
+        vm.expectRevert(
+            abi.encodeWithSelector(JB721TiersHookStore.JB721TiersHookStore_MissingReserveBeneficiary.selector, 1)
+        );
+        store.recordAddTiers(initialTiers);
+    }
 
-        JB721TierConfig[] memory laterTiers = new JB721TierConfig[](1);
-        laterTiers[0] = _tier({
+    /// @notice Creating a tier with reserveFrequency > 0 and no beneficiary (tier-specific or default)
+    /// is now rejected at creation time. This prevents the retroactive reserve activation scenario entirely.
+    function test_nonSoldOutTier_reservesStillWork_afterDefaultBeneficiaryChange() external {
+        // Attempt to add a tier with reserve frequency but no beneficiary — should revert.
+        JB721TierConfig[] memory initialTiers = new JB721TierConfig[](1);
+        initialTiers[0] = _tier({
             price: 1,
-            initialSupply: 10,
-            reserveFrequency: 2,
-            reserveBeneficiary: address(0xBEEF),
-            useReserveBeneficiaryAsDefault: true,
-            category: 2
+            initialSupply: 100,
+            reserveFrequency: 5,
+            reserveBeneficiary: address(0),
+            useReserveBeneficiaryAsDefault: false,
+            category: 1
         });
-        store.recordAddTiers(laterTiers);
-
-        JB721Tier memory afterDefault = store.tierOf({hook: address(this), id: 1, includeResolvedUri: false});
-        assertEq(afterDefault.remainingSupply, 0);
-        assertEq(afterDefault.reserveFrequency, 2);
-        assertEq(afterDefault.reserveBeneficiary, address(0xBEEF));
-        assertEq(store.numberOfPendingReservesFor({hook: address(this), tierId: 1}), 5);
-        assertEq(store.totalCashOutWeight(address(this)), 15);
 
-        vm.expectRevert();
-        store.recordMintReservesFor({tierId: 1, count: 1});
+        vm.expectRevert(
+            abi.encodeWithSelector(JB721TiersHookStore.JB721TiersHookStore_MissingReserveBeneficiary.selector, 1)
+        );
+        store.recordAddTiers(initialTiers);
     }
 
     function _tier(

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/audit/RetroactiveReserveBeneficiaryDilution.t.sol

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+// forge-lint: disable-next-line(unaliased-plain-import)
+import "../utils/UnitTestSetup.sol";
+import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
+import {JBAfterPayRecordedContext} from "@bananapus/core-v6/src/structs/JBAfterPayRecordedContext.sol";
+import {JB721TierConfigFlags} from "../../src/structs/JB721TierConfigFlags.sol";
+import {JB721TiersHookStore} from "../../src/JB721TiersHookStore.sol";
+
+contract RetroactiveReserveBeneficiaryDilution is UnitTestSetup {
+    /// @notice Creating a tier with reserveFrequency > 0 but no beneficiary (tier-specific or default) now reverts,
+    /// preventing the phantom reserve scenario where a later default beneficiary retroactively inflates
+    /// totalCashOutWeight and dilutes existing holders.
+    function test_adjustTier_reverts_when_reserve_has_no_beneficiary() public {
+        ForTest_JB721TiersHook testHook = _initializeForTestHook(0);
+
+        JB721TierConfig[] memory tier1 = new JB721TierConfig[](1);
+        tier1[0] = JB721TierConfig({
+            price: 1 ether,
+            initialSupply: 100,
+            votingUnits: 0,
+            reserveFrequency: 2,
+            reserveBeneficiary: address(0),
+            encodedIPFSUri: bytes32(uint256(0x1234)),
+            category: 1,
+            discountPercent: 0,
+            flags: JB721TierConfigFlags({
+                allowOwnerMint: false,
+                useReserveBeneficiaryAsDefault: false,
+                transfersPausable: false,
+                useVotingUnits: false,
+                cantBeRemoved: false,
+                cantIncreaseDiscountPercent: false,
+                cantBuyWithCredits: false
+            }),
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+
+        vm.prank(owner);
+        vm.expectRevert(
+            abi.encodeWithSelector(JB721TiersHookStore.JB721TiersHookStore_MissingReserveBeneficiary.selector, 1)
+        );
+        testHook.adjustTiers(tier1, new uint256[](0));
+    }
+
+    /// @notice A tier with reserveFrequency > 0 succeeds when an explicit beneficiary is provided.
+    function test_adjustTier_succeeds_with_explicit_reserve_beneficiary() public {
+        ForTest_JB721TiersHook testHook = _initializeForTestHook(0);
+
+        JB721TierConfig[] memory tier1 = new JB721TierConfig[](1);
+        tier1[0] = JB721TierConfig({
+            price: 1 ether,
+            initialSupply: 100,
+            votingUnits: 0,
+            reserveFrequency: 2,
+            reserveBeneficiary: owner,
+            encodedIPFSUri: bytes32(uint256(0x1234)),
+            category: 1,
+            discountPercent: 0,
+            flags: JB721TierConfigFlags({
+                allowOwnerMint: false,
+                useReserveBeneficiaryAsDefault: false,
+                transfersPausable: false,
+                useVotingUnits: false,
+                cantBeRemoved: false,
+                cantIncreaseDiscountPercent: false,
+                cantBuyWithCredits: false
+            }),
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+
+        vm.prank(owner);
+        testHook.adjustTiers(tier1, new uint256[](0));
+
+        assertEq(
+            testHook.STORE().reserveBeneficiaryOf(address(testHook), 1),
+            owner,
+            "tier-specific beneficiary should be set"
+        );
+    }
+
+    /// @notice A tier with reserveFrequency > 0 and no explicit beneficiary succeeds when a default beneficiary
+    /// was previously set by an earlier tier.
+    function test_adjustTier_succeeds_with_default_reserve_beneficiary() public {
+        ForTest_JB721TiersHook testHook = _initializeForTestHook(0);
+
+        // Add two tiers: first sets the default beneficiary, second relies on it.
+        JB721TierConfig[] memory tiers = new JB721TierConfig[](2);
+
+        // Tier 1: sets default beneficiary via useReserveBeneficiaryAsDefault.
+        tiers[0] = JB721TierConfig({
+            price: 1 ether,
+            initialSupply: 100,
+            votingUnits: 0,
+            reserveFrequency: 2,
+            reserveBeneficiary: owner,
+            encodedIPFSUri: bytes32(uint256(0x1234)),
+            category: 1,
+            discountPercent: 0,
+            flags: JB721TierConfigFlags({
+                allowOwnerMint: false,
+                useReserveBeneficiaryAsDefault: true,
+                transfersPausable: false,
+                useVotingUnits: false,
+                cantBeRemoved: false,
+                cantIncreaseDiscountPercent: false,
+                cantBuyWithCredits: false
+            }),
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+
+        // Tier 2: relies on the default beneficiary (no explicit one).
+        tiers[1] = JB721TierConfig({
+            price: 2 ether,
+            initialSupply: 100,
+            votingUnits: 0,
+            reserveFrequency: 3,
+            reserveBeneficiary: address(0),
+            encodedIPFSUri: bytes32(uint256(0x5678)),
+            category: 2,
+            discountPercent: 0,
+            flags: JB721TierConfigFlags({
+                allowOwnerMint: false,
+                useReserveBeneficiaryAsDefault: false,
+                transfersPausable: false,
+                useVotingUnits: false,
+                cantBeRemoved: false,
+                cantIncreaseDiscountPercent: false,
+                cantBuyWithCredits: false
+            }),
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+
+        vm.prank(owner);
+        testHook.adjustTiers(tiers, new uint256[](0));
+
+        // Tier 2 should inherit the default beneficiary set by tier 1.
+        assertEq(
+            testHook.STORE().reserveBeneficiaryOf(address(testHook), 2),
+            owner,
+            "tier 2 should inherit default beneficiary"
+        );
+    }
+}

package/test/audit/{CodexSplitCreditsMismatch.t.sol → SplitCreditsMismatch.t.sol}

@@ -15,7 +15,7 @@ import {JB721TierConfigFlags} from "../../src/structs/JB721TierConfigFlags.sol";
 /// @notice Regression test: split metadata is proportionally scaled when credits fund a split-bearing tier mint.
 /// @dev Previously (pre-fix), the per-tier split amounts were left at the uncapped value, trapping forwarded ETH.
 /// After the F-2 fix, split amounts are scaled down to match the actual forwarded amount.
-contract CodexSplitCreditsMismatch is UnitTestSetup {
+contract SplitCreditsMismatch is UnitTestSetup {
     address internal splitBeneficiary = makeAddr("splitBeneficiary");
 
     function setUp() public override {

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;