@bananapus/721-hook-v6 0.0.1

package/test/unit/JB721TiersRulesetMetadataResolver.t.sol

@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import "forge-std/Test.sol";
+
+import {JB721TiersRulesetMetadataResolver} from "../../src/libraries/JB721TiersRulesetMetadataResolver.sol";
+import {JB721TiersRulesetMetadata} from "../../src/structs/JB721TiersRulesetMetadata.sol";
+
+/// @notice Unit + fuzz tests for `JB721TiersRulesetMetadataResolver`.
+contract TestJB721TiersRulesetMetadataResolver is Test {
+    //*********************************************************************//
+    // --- pack: individual flags ---------------------------------------- //
+    //*********************************************************************//
+
+    function test_pack_allFalse() public {
+        JB721TiersRulesetMetadata memory meta =
+            JB721TiersRulesetMetadata({pauseTransfers: false, pauseMintPendingReserves: false});
+        uint256 packed = JB721TiersRulesetMetadataResolver.pack721TiersRulesetMetadata(meta);
+        assertEq(packed, 0, "both false should pack to 0");
+    }
+
+    function test_pack_pauseTransfersOnly() public {
+        JB721TiersRulesetMetadata memory meta =
+            JB721TiersRulesetMetadata({pauseTransfers: true, pauseMintPendingReserves: false});
+        uint256 packed = JB721TiersRulesetMetadataResolver.pack721TiersRulesetMetadata(meta);
+        assertEq(packed, 1, "pauseTransfers only should pack to 1");
+    }
+
+    function test_pack_pauseMintPendingReservesOnly() public {
+        JB721TiersRulesetMetadata memory meta =
+            JB721TiersRulesetMetadata({pauseTransfers: false, pauseMintPendingReserves: true});
+        uint256 packed = JB721TiersRulesetMetadataResolver.pack721TiersRulesetMetadata(meta);
+        assertEq(packed, 2, "pauseMintPendingReserves only should pack to 2");
+    }
+
+    function test_pack_bothTrue() public {
+        JB721TiersRulesetMetadata memory meta =
+            JB721TiersRulesetMetadata({pauseTransfers: true, pauseMintPendingReserves: true});
+        uint256 packed = JB721TiersRulesetMetadataResolver.pack721TiersRulesetMetadata(meta);
+        assertEq(packed, 3, "both true should pack to 3");
+    }
+
+    //*********************************************************************//
+    // --- transfersPaused / mintPendingReservesPaused -------------------- //
+    //*********************************************************************//
+
+    function test_transfersPaused() public {
+        assertFalse(JB721TiersRulesetMetadataResolver.transfersPaused(0));
+        assertTrue(JB721TiersRulesetMetadataResolver.transfersPaused(1));
+        assertFalse(JB721TiersRulesetMetadataResolver.transfersPaused(2));
+        assertTrue(JB721TiersRulesetMetadataResolver.transfersPaused(3));
+    }
+
+    function test_mintPendingReservesPaused() public {
+        assertFalse(JB721TiersRulesetMetadataResolver.mintPendingReservesPaused(0));
+        assertFalse(JB721TiersRulesetMetadataResolver.mintPendingReservesPaused(1));
+        assertTrue(JB721TiersRulesetMetadataResolver.mintPendingReservesPaused(2));
+        assertTrue(JB721TiersRulesetMetadataResolver.mintPendingReservesPaused(3));
+    }
+
+    //*********************************************************************//
+    // --- expandMetadata ------------------------------------------------ //
+    //*********************************************************************//
+
+    function test_expandMetadata_zero() public {
+        JB721TiersRulesetMetadata memory meta = JB721TiersRulesetMetadataResolver.expandMetadata(0);
+        assertFalse(meta.pauseTransfers);
+        assertFalse(meta.pauseMintPendingReserves);
+    }
+
+    function test_expandMetadata_one() public {
+        JB721TiersRulesetMetadata memory meta = JB721TiersRulesetMetadataResolver.expandMetadata(1);
+        assertTrue(meta.pauseTransfers);
+        assertFalse(meta.pauseMintPendingReserves);
+    }
+
+    function test_expandMetadata_two() public {
+        JB721TiersRulesetMetadata memory meta = JB721TiersRulesetMetadataResolver.expandMetadata(2);
+        assertFalse(meta.pauseTransfers);
+        assertTrue(meta.pauseMintPendingReserves);
+    }
+
+    function test_expandMetadata_three() public {
+        JB721TiersRulesetMetadata memory meta = JB721TiersRulesetMetadataResolver.expandMetadata(3);
+        assertTrue(meta.pauseTransfers);
+        assertTrue(meta.pauseMintPendingReserves);
+    }
+
+    //*********************************************************************//
+    // --- Round-Trip ----------------------------------------------------- //
+    //*********************************************************************//
+
+    function test_packExpandRoundTrip_allCombinations() public {
+        for (uint256 i; i < 4; i++) {
+            bool transfers = (i & 1) == 1;
+            bool reserves = (i & 2) == 2;
+
+            JB721TiersRulesetMetadata memory meta =
+                JB721TiersRulesetMetadata({pauseTransfers: transfers, pauseMintPendingReserves: reserves});
+
+            uint256 packed = JB721TiersRulesetMetadataResolver.pack721TiersRulesetMetadata(meta);
+            JB721TiersRulesetMetadata memory expanded = JB721TiersRulesetMetadataResolver.expandMetadata(uint16(packed));
+
+            assertEq(expanded.pauseTransfers, transfers, "transfers round-trip");
+            assertEq(expanded.pauseMintPendingReserves, reserves, "reserves round-trip");
+        }
+    }
+
+    //*********************************************************************//
+    // --- Fuzz ---------------------------------------------------------- //
+    //*********************************************************************//
+
+    function testFuzz_packExpandRoundTrip(bool pauseTransfers, bool pauseMintPendingReserves) public {
+        JB721TiersRulesetMetadata memory meta = JB721TiersRulesetMetadata({
+            pauseTransfers: pauseTransfers, pauseMintPendingReserves: pauseMintPendingReserves
+        });
+
+        uint256 packed = JB721TiersRulesetMetadataResolver.pack721TiersRulesetMetadata(meta);
+        JB721TiersRulesetMetadata memory expanded = JB721TiersRulesetMetadataResolver.expandMetadata(uint16(packed));
+
+        assertEq(expanded.pauseTransfers, pauseTransfers, "fuzz transfers round-trip");
+        assertEq(expanded.pauseMintPendingReserves, pauseMintPendingReserves, "fuzz reserves round-trip");
+    }
+
+    function testFuzz_transfersPaused_bitIsolation(uint256 data) public {
+        bool result = JB721TiersRulesetMetadataResolver.transfersPaused(data);
+        assertEq(result, (data & 1) == 1, "transfersPaused should check bit 0");
+    }
+
+    function testFuzz_mintPendingReservesPaused_bitIsolation(uint256 data) public {
+        bool result = JB721TiersRulesetMetadataResolver.mintPendingReservesPaused(data);
+        assertEq(result, ((data >> 1) & 1) == 1, "mintPendingReservesPaused should check bit 1");
+    }
+
+    function testFuzz_pack_onlyUsesLow2Bits(bool a, bool b) public {
+        JB721TiersRulesetMetadata memory meta =
+            JB721TiersRulesetMetadata({pauseTransfers: a, pauseMintPendingReserves: b});
+        uint256 packed = JB721TiersRulesetMetadataResolver.pack721TiersRulesetMetadata(meta);
+        assertEq(packed & ~uint256(3), 0, "packed value should only use bits 0 and 1");
+    }
+}

package/test/unit/JBBitmap.t.sol

@@ -0,0 +1,169 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import "forge-std/Test.sol";
+
+import {JBBitmap} from "../../src/libraries/JBBitmap.sol";
+import {JBBitmapWord} from "../../src/structs/JBBitmapWord.sol";
+
+/// @notice Unit + fuzz tests for `JBBitmap`.
+contract TestJBBitmap is Test {
+    using JBBitmap for mapping(uint256 => uint256);
+    using JBBitmap for JBBitmapWord;
+
+    mapping(uint256 => uint256) internal bitmap;
+
+    //*********************************************************************//
+    // --- readId -------------------------------------------------------- //
+    //*********************************************************************//
+
+    function test_readId_initiallyZero() public {
+        JBBitmapWord memory word = bitmap.readId(0);
+        assertEq(word.currentWord, 0, "initial word should be 0");
+        assertEq(word.currentDepth, 0, "depth for index 0 should be 0");
+    }
+
+    function test_readId_depthCalculation() public {
+        // Index 255 is in depth 0, index 256 is in depth 1.
+        JBBitmapWord memory word0 = bitmap.readId(255);
+        assertEq(word0.currentDepth, 0, "index 255 should be depth 0");
+
+        JBBitmapWord memory word1 = bitmap.readId(256);
+        assertEq(word1.currentDepth, 1, "index 256 should be depth 1");
+
+        JBBitmapWord memory word2 = bitmap.readId(512);
+        assertEq(word2.currentDepth, 2, "index 512 should be depth 2");
+    }
+
+    //*********************************************************************//
+    // --- removeTier / isTierIdRemoved ---------------------------------- //
+    //*********************************************************************//
+
+    function test_removeTier_setsbit() public {
+        assertFalse(bitmap.isTierIdRemoved(5), "should not be removed initially");
+
+        bitmap.removeTier(5);
+
+        assertTrue(bitmap.isTierIdRemoved(5), "should be removed after removeTier");
+    }
+
+    function test_removeTier_doesNotAffectOtherBits() public {
+        bitmap.removeTier(5);
+
+        assertFalse(bitmap.isTierIdRemoved(4), "adjacent bit should not be affected");
+        assertFalse(bitmap.isTierIdRemoved(6), "adjacent bit should not be affected");
+        assertFalse(bitmap.isTierIdRemoved(0), "index 0 should not be affected");
+    }
+
+    function test_removeTier_multipleBitsInSameWord() public {
+        bitmap.removeTier(0);
+        bitmap.removeTier(1);
+        bitmap.removeTier(255);
+
+        assertTrue(bitmap.isTierIdRemoved(0));
+        assertTrue(bitmap.isTierIdRemoved(1));
+        assertTrue(bitmap.isTierIdRemoved(255));
+        assertFalse(bitmap.isTierIdRemoved(2));
+    }
+
+    function test_removeTier_acrossWords() public {
+        bitmap.removeTier(0); // depth 0
+        bitmap.removeTier(256); // depth 1
+        bitmap.removeTier(512); // depth 2
+
+        assertTrue(bitmap.isTierIdRemoved(0));
+        assertTrue(bitmap.isTierIdRemoved(256));
+        assertTrue(bitmap.isTierIdRemoved(512));
+
+        assertFalse(bitmap.isTierIdRemoved(1));
+        assertFalse(bitmap.isTierIdRemoved(257));
+        assertFalse(bitmap.isTierIdRemoved(513));
+    }
+
+    function test_removeTier_idempotent() public {
+        bitmap.removeTier(10);
+        bitmap.removeTier(10); // Remove again.
+        assertTrue(bitmap.isTierIdRemoved(10), "should still be removed");
+    }
+
+    //*********************************************************************//
+    // --- isTierIdRemoved (memory struct variant) ----------------------- //
+    //*********************************************************************//
+
+    function test_isTierIdRemoved_memoryStruct() public {
+        bitmap.removeTier(3);
+
+        JBBitmapWord memory word = bitmap.readId(3);
+        assertTrue(word.isTierIdRemoved(3), "memory struct should read removed bit");
+        assertFalse(word.isTierIdRemoved(4), "memory struct should read non-removed bit");
+    }
+
+    function test_isTierIdRemoved_wrongDepthReturnsWrong() public {
+        bitmap.removeTier(3); // depth 0
+
+        // Read a word from depth 1 — should not see index 3's removal.
+        JBBitmapWord memory word = bitmap.readId(256);
+        assertFalse(word.isTierIdRemoved(3), "wrong depth should not see bit");
+    }
+
+    //*********************************************************************//
+    // --- refreshBitmapNeeded ------------------------------------------- //
+    //*********************************************************************//
+
+    function test_refreshBitmapNeeded_sameDepth() public {
+        JBBitmapWord memory word = bitmap.readId(0);
+        assertFalse(word.refreshBitmapNeeded(100), "same depth should not need refresh");
+        assertFalse(word.refreshBitmapNeeded(255), "still depth 0, no refresh needed");
+    }
+
+    function test_refreshBitmapNeeded_differentDepth() public {
+        JBBitmapWord memory word = bitmap.readId(0);
+        assertTrue(word.refreshBitmapNeeded(256), "depth 1 should need refresh from depth 0");
+        assertTrue(word.refreshBitmapNeeded(512), "depth 2 should need refresh from depth 0");
+    }
+
+    //*********************************************************************//
+    // --- Fuzz Tests ---------------------------------------------------- //
+    //*********************************************************************//
+
+    function testFuzz_removeTier_roundTrip(uint16 index) public {
+        assertFalse(bitmap.isTierIdRemoved(index), "should start unremoved");
+
+        bitmap.removeTier(index);
+
+        assertTrue(bitmap.isTierIdRemoved(index), "should be removed after removeTier");
+    }
+
+    function testFuzz_removeTier_isolatedBit(uint16 indexA, uint16 indexB) public {
+        vm.assume(indexA != indexB);
+
+        bitmap.removeTier(indexA);
+
+        assertTrue(bitmap.isTierIdRemoved(indexA), "A should be removed");
+        assertFalse(bitmap.isTierIdRemoved(indexB), "B should not be removed");
+    }
+
+    function testFuzz_readId_depthMatchesIndex(uint16 index) public {
+        JBBitmapWord memory word = bitmap.readId(index);
+        assertEq(word.currentDepth, uint256(index) >> 8, "depth should be index / 256");
+    }
+
+    function testFuzz_refreshBitmapNeeded_consistency(uint16 indexA, uint16 indexB) public {
+        JBBitmapWord memory word = bitmap.readId(indexA);
+        bool needed = word.refreshBitmapNeeded(indexB);
+        // Refresh is needed iff depths differ.
+        assertEq(needed, (uint256(indexA) >> 8) != (uint256(indexB) >> 8), "refresh iff different depth");
+    }
+
+    function testFuzz_removeTier_multipleBits(uint8 a, uint8 b, uint8 c) public {
+        vm.assume(a != b && b != c && a != c);
+
+        bitmap.removeTier(a);
+        bitmap.removeTier(b);
+        bitmap.removeTier(c);
+
+        assertTrue(bitmap.isTierIdRemoved(a));
+        assertTrue(bitmap.isTierIdRemoved(b));
+        assertTrue(bitmap.isTierIdRemoved(c));
+    }
+}

package/test/unit/JBIpfsDecoder.t.sol

@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import "forge-std/Test.sol";
+
+import {JBIpfsDecoder} from "../../src/libraries/JBIpfsDecoder.sol";
+
+/// @notice Unit tests for `JBIpfsDecoder`.
+contract TestJBIpfsDecoder is Test {
+    /// @notice Known IPFS CID v0 hash for testing.
+    /// @dev Obtained by hashing a known payload: the CID for the hex 0x1220... prefix + this hash should decode to a
+    /// valid base58 string starting with "Qm".
+    bytes32 constant TEST_HASH = 0x7465737468617368000000000000000000000000000000000000000000000000;
+
+    //*********************************************************************//
+    // --- decode: basic output ------------------------------------------ //
+    //*********************************************************************//
+
+    function test_decode_prependsBaseUri() public {
+        string memory result = JBIpfsDecoder.decode("ipfs://", TEST_HASH);
+        // Result must start with the base URI.
+        bytes memory resultBytes = bytes(result);
+        bytes memory prefix = bytes("ipfs://");
+        for (uint256 i; i < prefix.length; i++) {
+            assertEq(resultBytes[i], prefix[i], "prefix mismatch");
+        }
+    }
+
+    function test_decode_emptyBaseUri() public {
+        string memory result = JBIpfsDecoder.decode("", TEST_HASH);
+        // Should still produce a non-empty base58 hash.
+        assertTrue(bytes(result).length > 0, "should produce output with empty base URI");
+    }
+
+    function test_decode_outputStartsWithQm() public {
+        // All CIDv0 hashes start with "Qm" because the 0x1220 prefix encodes to "Qm" in base58.
+        string memory result = JBIpfsDecoder.decode("", TEST_HASH);
+        bytes memory resultBytes = bytes(result);
+        assertEq(resultBytes[0], bytes1("Q"), "first char should be Q");
+        assertEq(resultBytes[1], bytes1("m"), "second char should be m");
+    }
+
+    function test_decode_outputLength() public {
+        // CIDv0 hashes are always 46 characters in base58.
+        string memory result = JBIpfsDecoder.decode("", TEST_HASH);
+        assertEq(bytes(result).length, 46, "CIDv0 base58 hash should be 46 characters");
+    }
+
+    //*********************************************************************//
+    // --- decode: determinism ------------------------------------------- //
+    //*********************************************************************//
+
+    function test_decode_deterministic() public {
+        string memory a = JBIpfsDecoder.decode("ipfs://", TEST_HASH);
+        string memory b = JBIpfsDecoder.decode("ipfs://", TEST_HASH);
+        assertEq(keccak256(bytes(a)), keccak256(bytes(b)), "same input should produce same output");
+    }
+
+    function test_decode_differentHashesDifferentOutput() public {
+        bytes32 hashA = bytes32(uint256(1));
+        bytes32 hashB = bytes32(uint256(2));
+        string memory a = JBIpfsDecoder.decode("", hashA);
+        string memory b = JBIpfsDecoder.decode("", hashB);
+        assertTrue(keccak256(bytes(a)) != keccak256(bytes(b)), "different hashes should produce different output");
+    }
+
+    //*********************************************************************//
+    // --- decode: base58 alphabet --------------------------------------- //
+    //*********************************************************************//
+
+    function test_decode_onlyBase58Chars() public {
+        string memory result = JBIpfsDecoder.decode("", TEST_HASH);
+        bytes memory resultBytes = bytes(result);
+        bytes memory alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+
+        for (uint256 i; i < resultBytes.length; i++) {
+            bool found;
+            for (uint256 j; j < alphabet.length; j++) {
+                if (resultBytes[i] == alphabet[j]) {
+                    found = true;
+                    break;
+                }
+            }
+            assertTrue(found, "output should only contain base58 characters");
+        }
+    }
+
+    //*********************************************************************//
+    // --- decode: fuzz -------------------------------------------------- //
+    //*********************************************************************//
+
+    function testFuzz_decode_alwaysProduces46Chars(bytes32 hash) public {
+        string memory result = JBIpfsDecoder.decode("", hash);
+        assertEq(bytes(result).length, 46, "any hash should produce 46-char CIDv0");
+    }
+
+    function testFuzz_decode_alwaysStartsWithQm(bytes32 hash) public {
+        string memory result = JBIpfsDecoder.decode("", hash);
+        bytes memory resultBytes = bytes(result);
+        assertEq(resultBytes[0], bytes1("Q"), "first char should be Q");
+        assertEq(resultBytes[1], bytes1("m"), "second char should be m");
+    }
+
+    function testFuzz_decode_prependsBaseUri(bytes32 hash, uint8 baseLen) public {
+        // Create a base URI of varying length (0-255 chars).
+        bytes memory base = new bytes(baseLen);
+        for (uint256 i; i < baseLen; i++) {
+            base[i] = "x";
+        }
+        string memory baseUri = string(base);
+        string memory result = JBIpfsDecoder.decode(baseUri, hash);
+        assertEq(bytes(result).length, uint256(baseLen) + 46, "output length = base + 46");
+    }
+
+    function testFuzz_decode_onlyBase58Chars(bytes32 hash) public {
+        string memory result = JBIpfsDecoder.decode("", hash);
+        bytes memory resultBytes = bytes(result);
+        bytes memory alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+
+        for (uint256 i; i < resultBytes.length; i++) {
+            bool found;
+            for (uint256 j; j < alphabet.length; j++) {
+                if (resultBytes[i] == alphabet[j]) {
+                    found = true;
+                    break;
+                }
+            }
+            assertTrue(found, "all chars should be in base58 alphabet");
+        }
+    }
+}

package/test/unit/M6_TierSupplyCheck.t.sol

@@ -0,0 +1,220 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import "../utils/UnitTestSetup.sol";
+
+/// @title M6_TierSupplyCheck
+/// @notice Tests proving the M-6 fix: the supply check must account for pending reserves when minting paid NFTs.
+/// Without the `1 +` in the supply check, the last available slot can be consumed by a paid mint, making
+/// pending reserves unmintable (recordMintReservesFor reverts decrementing remainingSupply past zero).
+contract M6_TierSupplyCheck is UnitTestSetup {
+    using stdStorage for StdStorage;
+
+    /// @dev Mock the directory to accept `mockTerminalAddress` as a terminal for `projectId`.
+    function _mockTerminalAuth() internal {
+        mockAndExpect(
+            mockJBDirectory,
+            abi.encodeWithSelector(IJBDirectory.isTerminalOf.selector, projectId, mockTerminalAddress),
+            abi.encode(true)
+        );
+    }
+
+    /// @dev Create a pay context that requests minting specific tier IDs.
+    function _buildPayContext(
+        address targetHook,
+        uint256 value,
+        uint16[] memory tierIds
+    )
+        internal
+        view
+        returns (JBAfterPayRecordedContext memory)
+    {
+        bytes[] memory data = new bytes[](1);
+        data[0] = abi.encode(false, tierIds);
+        bytes4[] memory ids = new bytes4[](1);
+        ids[0] = metadataHelper.getId("pay", targetHook);
+        bytes memory hookMetadata = metadataHelper.createMetadata(ids, data);
+
+        return JBAfterPayRecordedContext({
+            payer: beneficiary,
+            projectId: projectId,
+            rulesetId: 0,
+            amount: JBTokenAmount({
+                token: JBConstants.NATIVE_TOKEN,
+                value: value,
+                decimals: 18,
+                currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+            }),
+            forwardedAmount: JBTokenAmount({
+                token: JBConstants.NATIVE_TOKEN,
+                value: 0,
+                decimals: 18,
+                currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+            }),
+            weight: 10 ** 18,
+            newlyIssuedTokenCount: 0,
+            beneficiary: beneficiary,
+            hookMetadata: bytes(""),
+            payerMetadata: hookMetadata
+        });
+    }
+
+    /// @dev Helper: mint `count` NFTs from tier 1 via pay.
+    function _mintPaid(ForTest_JB721TiersHook targetHook, uint256 count) internal {
+        uint16[] memory tierIds = new uint16[](count);
+        for (uint256 i; i < count; i++) {
+            tierIds[i] = 1;
+        }
+        JBAfterPayRecordedContext memory ctx = _buildPayContext(address(targetHook), count * 10, tierIds); // price=10
+        // per NFT
+        vm.prank(mockTerminalAddress);
+        targetHook.afterPayRecordedWith(ctx);
+    }
+
+    // =========================================================================
+    // Test 1: Prove the edge case — paid mint would steal reserves' last slot
+    // =========================================================================
+    /// @notice With reserveFrequency=2 and initialSupply=10:
+    /// After 6 paid mints → 4 remaining, 3 pending reserves.
+    /// Without the fix, a 7th paid mint would pass (4 > 3) leaving only 3 remaining for 4 pending reserves.
+    /// With the fix, the 7th mint decrements first (remaining→3), then checks 3 < ceil(7/2)=4 → reverts.
+    function test_M6_paidMintCannotStealReserveSlot() public {
+        // Configure: small supply, reserve every 2 mints.
+        defaultTierConfig.price = uint104(10);
+        defaultTierConfig.initialSupply = uint32(10);
+        defaultTierConfig.reserveFrequency = uint16(2);
+        defaultTierConfig.reserveBeneficiary = reserveBeneficiary;
+
+        ForTest_JB721TiersHook targetHook = _initializeForTestHook(1);
+        _mockTerminalAuth();
+
+        // Mint 6 paid NFTs. State: remaining=4, nonReserveMints=6, pending=ceil(6/2)=3.
+        _mintPaid(targetHook, 6);
+
+        JB721Tier memory tier = targetHook.STORE().tierOf(address(targetHook), 1, false);
+        assertEq(tier.remainingSupply, 4, "Should have 4 remaining after 6 mints");
+
+        uint256 pending = targetHook.STORE().numberOfPendingReservesFor(address(targetHook), 1);
+        assertEq(pending, 3, "Should have 3 pending reserves (ceil(6/2)=3)");
+
+        // The 7th paid mint should revert: remaining(4) <= 1 + pending(3) = 4.
+        // Without the fix (just `<=` pending), this would pass since 4 > 3.
+        uint16[] memory oneMore = new uint16[](1);
+        oneMore[0] = 1;
+        JBAfterPayRecordedContext memory ctx = _buildPayContext(address(targetHook), 10, oneMore);
+
+        vm.prank(mockTerminalAddress);
+        vm.expectRevert(
+            abi.encodeWithSelector(JB721TiersHookStore.JB721TiersHookStore_InsufficientSupplyRemaining.selector, 1)
+        );
+        targetHook.afterPayRecordedWith(ctx);
+    }
+
+    // =========================================================================
+    // Test 2: Reserves remain fully mintable after paid mints
+    // =========================================================================
+    /// @notice After minting paid NFTs up to the allowed limit, all pending reserves should be mintable.
+    function test_M6_reservesFullyMintableAfterPaidMints() public {
+        defaultTierConfig.price = uint104(10);
+        defaultTierConfig.initialSupply = uint32(10);
+        defaultTierConfig.reserveFrequency = uint16(2);
+        defaultTierConfig.reserveBeneficiary = reserveBeneficiary;
+
+        ForTest_JB721TiersHook targetHook = _initializeForTestHook(1);
+        _mockTerminalAuth();
+
+        // Mint 6 paid NFTs (the maximum allowed given the fix).
+        _mintPaid(targetHook, 6);
+
+        // Mint all pending reserves — this must succeed.
+        uint256 pending = targetHook.STORE().numberOfPendingReservesFor(address(targetHook), 1);
+        assertEq(pending, 3, "3 pending reserves");
+
+        vm.prank(owner);
+        targetHook.mintPendingReservesFor(1, pending);
+
+        // Verify: reserve beneficiary got the reserves.
+        assertEq(targetHook.balanceOf(reserveBeneficiary), pending, "Reserve beneficiary should have all reserves");
+
+        // Verify: remaining supply is 1 (10 - 6 paid - 3 reserves = 1).
+        JB721Tier memory tier = targetHook.STORE().tierOf(address(targetHook), 1, false);
+        assertEq(tier.remainingSupply, 1, "Should have 1 remaining (10 - 6 - 3)");
+    }
+
+    // =========================================================================
+    // Test 3: Boundary — reserves exactly fill remaining supply after max paid mints
+    // =========================================================================
+    /// @notice With reserveFrequency=5, after 16 paid mints of 20 supply:
+    /// remaining=4, pending=ceil(16/5)=4. The 17th mint reverts (4 <= 1+4=5).
+    /// All 4 pending reserves are still fully mintable.
+    function test_M6_noMintWhenRemainingEqualsReserves() public {
+        defaultTierConfig.price = uint104(10);
+        defaultTierConfig.initialSupply = uint32(20);
+        defaultTierConfig.reserveFrequency = uint16(5);
+        defaultTierConfig.reserveBeneficiary = reserveBeneficiary;
+
+        ForTest_JB721TiersHook targetHook = _initializeForTestHook(1);
+        _mockTerminalAuth();
+
+        // Mint 16 paid NFTs in two batches to stay under gas limits.
+        _mintPaid(targetHook, 10);
+        _mintPaid(targetHook, 6);
+
+        // State: remaining=4, nonReserveMints=16, pending=ceil(16/5)=4.
+        uint256 pending = targetHook.STORE().numberOfPendingReservesFor(address(targetHook), 1);
+        assertEq(pending, 4, "Should have 4 pending reserves (ceil(16/5)=4)");
+
+        JB721Tier memory tier = targetHook.STORE().tierOf(address(targetHook), 1, false);
+        assertEq(tier.remainingSupply, 4, "Should have 4 remaining");
+
+        // 17th mint: after decrement remaining would be 3, but pending would be ceil(17/5)=4. 3 < 4 → reverts.
+        uint16[] memory oneMore = new uint16[](1);
+        oneMore[0] = 1;
+        JBAfterPayRecordedContext memory ctx = _buildPayContext(address(targetHook), 10, oneMore);
+
+        vm.prank(mockTerminalAddress);
+        vm.expectRevert(
+            abi.encodeWithSelector(JB721TiersHookStore.JB721TiersHookStore_InsufficientSupplyRemaining.selector, 1)
+        );
+        targetHook.afterPayRecordedWith(ctx);
+
+        // But reserves should still be fully mintable — remaining(4) covers all pending(4).
+        vm.prank(owner);
+        targetHook.mintPendingReservesFor(1, pending);
+        assertEq(targetHook.balanceOf(reserveBeneficiary), 4, "All reserves fully minted");
+
+        // Final state: 0 remaining.
+        tier = targetHook.STORE().tierOf(address(targetHook), 1, false);
+        assertEq(tier.remainingSupply, 0, "Fully exhausted");
+    }
+
+    // =========================================================================
+    // Test 4: No reserves — full supply mintable
+    // =========================================================================
+    /// @notice Without reserves, all NFTs in a tier should be mintable (no off-by-one).
+    function test_M6_noReserves_fullSupplyMintable() public {
+        defaultTierConfig.price = uint104(10);
+        defaultTierConfig.initialSupply = uint32(5);
+        defaultTierConfig.reserveFrequency = uint16(0);
+        defaultTierConfig.reserveBeneficiary = address(0);
+
+        ForTest_JB721TiersHook targetHook = _initializeForTestHook(1);
+        _mockTerminalAuth();
+
+        // Mint all 5 — should succeed since no reserves to protect.
+        _mintPaid(targetHook, 5);
+
+        JB721Tier memory tier = targetHook.STORE().tierOf(address(targetHook), 1, false);
+        assertEq(tier.remainingSupply, 0, "Fully minted");
+        assertEq(targetHook.balanceOf(beneficiary), 5, "Beneficiary has all 5");
+
+        // One more should revert (supply exhausted).
+        uint16[] memory oneMore = new uint16[](1);
+        oneMore[0] = 1;
+        JBAfterPayRecordedContext memory ctx = _buildPayContext(address(targetHook), 10, oneMore);
+
+        vm.prank(mockTerminalAddress);
+        vm.expectRevert();
+        targetHook.afterPayRecordedWith(ctx);
+    }
+}