@bananapus/721-hook-v6 0.0.32 → 0.0.34

package/test/Fork.t.sol

@@ -66,6 +66,8 @@ import "../src/JB721TiersHookDeployer.sol";
 import "../src/JB721TiersHookProjectDeployer.sol";
 // forge-lint: disable-next-line(unaliased-plain-import)
 import "../src/JB721TiersHookStore.sol";
+import {JB721CheckpointsDeployer} from "../src/JB721CheckpointsDeployer.sol";
+import {IJB721CheckpointsDeployer} from "../src/interfaces/IJB721CheckpointsDeployer.sol";
 // forge-lint: disable-next-line(unaliased-plain-import)
 import "../src/interfaces/IJB721TiersHook.sol";
 // forge-lint: disable-next-line(unaliased-plain-import)
@@ -183,7 +185,7 @@ contract Fork_721Hook_Test is Test {
         jbPermissions = new JBPermissions(address(0));
         jbProjects = new JBProjects(multisig, address(0), address(0));
         jbDirectory = new JBDirectory(jbPermissions, jbProjects, multisig);
-        JBERC20 jbErc20 = new JBERC20();
+        JBERC20 jbErc20 = new JBERC20(jbPermissions, jbProjects);
         jbTokens = new JBTokens(jbDirectory, jbErc20);
         jbRulesets = new JBRulesets(jbDirectory);
         jbPrices = new JBPrices(jbDirectory, jbPermissions, jbProjects, multisig, address(0));
@@ -231,7 +233,14 @@ contract Fork_721Hook_Test is Test {
     function _deploy721Hook() internal {
         store = new JB721TiersHookStore();
         hookImpl = new JB721TiersHook(
-            jbDirectory, jbPermissions, jbPrices, jbRulesets, store, IJBSplits(address(jbSplits)), address(0)
+            jbDirectory,
+            jbPermissions,
+            jbPrices,
+            jbRulesets,
+            store,
+            IJBSplits(address(jbSplits)),
+            IJB721CheckpointsDeployer(address(new JB721CheckpointsDeployer())),
+            address(0)
         );
         addressRegistry = new JBAddressRegistry();
         hookDeployer = new JB721TiersHookDeployer(hookImpl, store, addressRegistry, address(0));

package/test/TestAuditGaps.sol

@@ -164,7 +164,7 @@ contract TestAuditGaps_Reentrancy is UnitTestSetup {
             weight: 10e18,
             newlyIssuedTokenCount: 0,
             beneficiary: beneficiary,
-            hookMetadata: abi.encode(splitTierIds, splitAmounts),
+            hookMetadata: abi.encode(beneficiary, beneficiary, abi.encode(splitTierIds, splitAmounts)),
             payerMetadata: payerMetadata
         });
     }

package/test/TestCheckpoints.t.sol

@@ -0,0 +1,329 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+// forge-lint: disable-next-line(unaliased-plain-import)
+import "./utils/UnitTestSetup.sol";
+// forge-lint: disable-next-line(unaliased-plain-import)
+import "./utils/ForTest_JB721TiersHook.sol";
+import {JB721Checkpoints} from "../src/JB721Checkpoints.sol";
+import {IJB721Checkpoints} from "../src/interfaces/IJB721Checkpoints.sol";
+import {IJB721TiersHook} from "../src/interfaces/IJB721TiersHook.sol";
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+
+/// @title TestCheckpoints
+/// @notice Tests the checkpoint module IVotes checkpointed voting power baked into the base hook:
+/// delegation, checkpoints, transfer, multi-tier, burn, and module deployment.
+contract TestCheckpoints is UnitTestSetup {
+    /// @notice Deploys a ForTest hook with the given number of tiers.
+    function _initializeHookWithCheckpoints(uint256 numberOfTiers) internal returns (ForTest_JB721TiersHook tiersHook) {
+        (JB721TierConfig[] memory tierConfigs,) = _createTiers(defaultTierConfig, numberOfTiers);
+
+        ForTest_JB721TiersHookStore hookStore = new ForTest_JB721TiersHookStore();
+
+        tiersHook = new ForTest_JB721TiersHook(
+            ForTest_JB721TiersHook.ForTestInitConfig({
+                projectId: projectId,
+                name: name,
+                symbol: symbol,
+                baseUri: baseUri,
+                tokenUriResolver: IJB721TokenUriResolver(mockTokenUriResolver),
+                contractUri: contractUri,
+                tiers: tierConfigs,
+                flags: JB721TiersHookFlags({
+                    preventOverspending: false,
+                    issueTokensForSplits: false,
+                    noNewTiersWithReserves: false,
+                    noNewTiersWithVotes: false,
+                    noNewTiersWithOwnerMinting: true
+                })
+            }),
+            IJBDirectory(mockJBDirectory),
+            IJBPrices(mockJBPrices),
+            IJBRulesets(mockJBRulesets),
+            IJB721TiersHookStore(address(hookStore)),
+            IJBSplits(mockJBSplits)
+        );
+
+        tiersHook.transferOwnership(owner);
+    }
+
+    // -------------------------------------------------------------------
+    // Test 1: Checkpoint module is deployed eagerly during initialize
+    // -------------------------------------------------------------------
+    function test_checkpointModule_isDeployed() public {
+        defaultTierConfig.flags.allowOwnerMint = true;
+        defaultTierConfig.reserveFrequency = 0;
+
+        ForTest_JB721TiersHook tiersHook = _initializeHookWithCheckpoints(1);
+
+        // CHECKPOINTS should be deployed immediately after initialization.
+        assertTrue(
+            address(tiersHook.CHECKPOINTS()) != address(0), "Checkpoint module should be deployed after initialization"
+        );
+    }
+
+    // -------------------------------------------------------------------
+    // Test 2: supportsInterface still works for base hook
+    // -------------------------------------------------------------------
+    function test_supportsInterface() public {
+        defaultTierConfig.flags.allowOwnerMint = true;
+        defaultTierConfig.reserveFrequency = 0;
+
+        ForTest_JB721TiersHook tiersHook = _initializeHookWithCheckpoints(1);
+
+        assertTrue(tiersHook.supportsInterface(type(IJB721TiersHook).interfaceId), "Should support IJB721TiersHook");
+    }
+
+    // -------------------------------------------------------------------
+    // Test 3: Mint + manual delegate -> getVotes equals tier votingUnits
+    // -------------------------------------------------------------------
+    function test_mintAndDelegate_getVotes() public {
+        defaultTierConfig.flags.allowOwnerMint = true;
+        defaultTierConfig.reserveFrequency = 0;
+        defaultTierConfig.flags.useVotingUnits = true;
+        defaultTierConfig.votingUnits = 100;
+
+        ForTest_JB721TiersHook tiersHook = _initializeHookWithCheckpoints(1);
+
+        address user = makeAddr("user");
+
+        // Mint an NFT to user (CHECKPOINTS already deployed during init).
+        uint16[] memory tiersToMint = new uint16[](1);
+        tiersToMint[0] = 1;
+        vm.prank(owner);
+        tiersHook.mintFor(tiersToMint, user);
+
+        IJB721Checkpoints module = tiersHook.CHECKPOINTS();
+
+        // Without delegation, getVotes should be 0.
+        assertEq(module.getVotes(user), 0, "Votes should be 0 before delegation");
+
+        // User self-delegates.
+        vm.prank(user);
+        module.delegate(user);
+
+        assertEq(module.getVotes(user), 100, "Votes should be 100 after delegation");
+    }
+
+    // -------------------------------------------------------------------
+    // Test 4: No auto-delegation — delegates(user) stays address(0) after mint
+    // -------------------------------------------------------------------
+    function test_noAutoDelegation_delegateStaysZero() public {
+        defaultTierConfig.flags.allowOwnerMint = true;
+        defaultTierConfig.reserveFrequency = 0;
+        defaultTierConfig.flags.useVotingUnits = true;
+        defaultTierConfig.votingUnits = 100;
+
+        ForTest_JB721TiersHook tiersHook = _initializeHookWithCheckpoints(1);
+
+        address user = makeAddr("user");
+
+        // Mint an NFT to user (CHECKPOINTS already deployed during init).
+        uint16[] memory tiersToMint = new uint16[](1);
+        tiersToMint[0] = 1;
+        vm.prank(owner);
+        tiersHook.mintFor(tiersToMint, user);
+
+        IJB721Checkpoints module = tiersHook.CHECKPOINTS();
+
+        // Delegate should be address(0) — no auto-delegation.
+        assertEq(module.delegates(user), address(0), "Delegate should be zero after mint");
+    }
+
+    // -------------------------------------------------------------------
+    // Test 5: Transfer moves checkpointed votes (with manual delegation)
+    // -------------------------------------------------------------------
+    function test_transfer_movesCheckpointedVotes() public {
+        defaultTierConfig.flags.allowOwnerMint = true;
+        defaultTierConfig.reserveFrequency = 0;
+        defaultTierConfig.flags.useVotingUnits = true;
+        defaultTierConfig.votingUnits = 100;
+
+        ForTest_JB721TiersHook tiersHook = _initializeHookWithCheckpoints(1);
+
+        address alice = makeAddr("alice");
+        address bob = makeAddr("bob");
+
+        // Mint to alice (CHECKPOINTS already deployed during init).
+        uint16[] memory tiersToMint = new uint16[](1);
+        tiersToMint[0] = 1;
+        vm.prank(owner);
+        tiersHook.mintFor(tiersToMint, alice);
+
+        IJB721Checkpoints module = tiersHook.CHECKPOINTS();
+
+        // Both delegate to themselves.
+        vm.prank(alice);
+        module.delegate(alice);
+        vm.prank(bob);
+        module.delegate(bob);
+
+        assertEq(module.getVotes(alice), 100, "Alice should have 100 votes");
+        assertEq(module.getVotes(bob), 0, "Bob should have 0 votes");
+
+        // Transfer NFT from alice to bob.
+        uint256 tokenId = _generateTokenId(1, 1);
+        vm.prank(alice);
+        IERC721(address(tiersHook)).transferFrom(alice, bob, tokenId);
+
+        assertEq(module.getVotes(alice), 0, "Alice should have 0 votes after transfer");
+        assertEq(module.getVotes(bob), 100, "Bob should have 100 votes after transfer");
+    }
+
+    // -------------------------------------------------------------------
+    // Test 6: getPastVotes / getPastTotalSupply checkpoints
+    // -------------------------------------------------------------------
+    function test_getPastVotes_checkpoint() public {
+        defaultTierConfig.flags.allowOwnerMint = true;
+        defaultTierConfig.reserveFrequency = 0;
+        defaultTierConfig.flags.useVotingUnits = true;
+        defaultTierConfig.votingUnits = 100;
+
+        ForTest_JB721TiersHook tiersHook = _initializeHookWithCheckpoints(1);
+
+        address user = makeAddr("user");
+
+        // Mint first NFT to test checkpoint tracking.
+        uint16[] memory tiersToMint = new uint16[](1);
+        tiersToMint[0] = 1;
+        vm.prank(owner);
+        tiersHook.mintFor(tiersToMint, user);
+
+        IJB721Checkpoints module = tiersHook.CHECKPOINTS();
+
+        // User self-delegates so checkpoints are created going forward.
+        vm.prank(user);
+        module.delegate(user);
+
+        uint256 blockBeforeSecondMint = block.number;
+        vm.roll(block.number + 1);
+
+        // Mint a second NFT.
+        vm.prank(owner);
+        tiersHook.mintFor(tiersToMint, user);
+
+        uint256 blockAfterSecondMint = block.number;
+        vm.roll(block.number + 1);
+
+        // Past votes before second mint = 100 (from first NFT + delegation).
+        assertEq(module.getPastVotes(user, blockBeforeSecondMint), 100, "Past votes before second mint should be 100");
+        // Past votes after second mint = 200.
+        assertEq(module.getPastVotes(user, blockAfterSecondMint), 200, "Past votes after second mint should be 200");
+
+        // Past total supply.
+        assertEq(
+            module.getPastTotalSupply(blockBeforeSecondMint), 100, "Past total supply before second mint should be 100"
+        );
+        assertEq(
+            module.getPastTotalSupply(blockAfterSecondMint), 200, "Past total supply after second mint should be 200"
+        );
+    }
+
+    // -------------------------------------------------------------------
+    // Test 7: Multi-tier with different voting units
+    // -------------------------------------------------------------------
+    function test_multiTier_differentVotingUnits() public {
+        defaultTierConfig.flags.allowOwnerMint = true;
+        defaultTierConfig.reserveFrequency = 0;
+        defaultTierConfig.flags.useVotingUnits = true;
+
+        ForTest_JB721TiersHook tiersHook = _initializeHookWithCheckpoints(3);
+
+        // Set custom voting units per tier.
+        tiersHook.test_store().ForTest_setTierVotingUnits(address(tiersHook), 1, 100);
+        tiersHook.test_store().ForTest_setTierVotingUnits(address(tiersHook), 2, 200);
+        tiersHook.test_store().ForTest_setTierVotingUnits(address(tiersHook), 3, 500);
+
+        address user = makeAddr("user");
+
+        // Mint one from tier 1 to test checkpoint tracking.
+        uint16[] memory tier1 = new uint16[](1);
+        tier1[0] = 1;
+        vm.prank(owner);
+        tiersHook.mintFor(tier1, user);
+
+        IJB721Checkpoints module = tiersHook.CHECKPOINTS();
+
+        // User self-delegates.
+        vm.prank(user);
+        module.delegate(user);
+
+        // Mint from remaining tiers.
+        uint16[] memory tier2 = new uint16[](1);
+        tier2[0] = 2;
+        uint16[] memory tier3 = new uint16[](1);
+        tier3[0] = 3;
+
+        vm.startPrank(owner);
+        tiersHook.mintFor(tier2, user);
+        tiersHook.mintFor(tier3, user);
+        vm.stopPrank();
+
+        // 100 + 200 + 500 = 800.
+        assertEq(module.getVotes(user), 800, "User should have 800 checkpointed votes");
+    }
+
+    // -------------------------------------------------------------------
+    // Test 8: Burn decreases checkpointed total supply
+    // -------------------------------------------------------------------
+    function test_burn_decreasesTotalSupply() public {
+        defaultTierConfig.flags.allowOwnerMint = true;
+        defaultTierConfig.reserveFrequency = 0;
+        defaultTierConfig.flags.useVotingUnits = true;
+        defaultTierConfig.votingUnits = 100;
+
+        ForTest_JB721TiersHook tiersHook = _initializeHookWithCheckpoints(1);
+
+        address user = makeAddr("user");
+
+        // Mint 2 NFTs (first one deploys CHECKPOINTS lazily).
+        uint16[] memory tiersToMint = new uint16[](2);
+        tiersToMint[0] = 1;
+        tiersToMint[1] = 1;
+        vm.prank(owner);
+        tiersHook.mintFor(tiersToMint, user);
+
+        IJB721Checkpoints module = tiersHook.CHECKPOINTS();
+
+        // User self-delegates.
+        vm.prank(user);
+        module.delegate(user);
+
+        assertEq(module.getVotes(user), 200, "User should have 200 votes from 2 NFTs");
+
+        uint256 blockBeforeBurn = block.number;
+        vm.roll(block.number + 1);
+
+        // Burn one NFT.
+        uint256[] memory tokensToBurn = new uint256[](1);
+        tokensToBurn[0] = _generateTokenId(1, 1);
+        tiersHook.burn(tokensToBurn);
+
+        assertEq(module.getVotes(user), 100, "User should have 100 votes after burning 1 NFT");
+
+        vm.roll(block.number + 1);
+
+        assertEq(module.getPastTotalSupply(blockBeforeBurn), 200, "Past total supply before burn should be 200");
+    }
+
+    // -------------------------------------------------------------------
+    // Test 9: Unauthorized onTransfer reverts
+    // -------------------------------------------------------------------
+    function test_unauthorizedOnTransfer_reverts() public {
+        defaultTierConfig.flags.allowOwnerMint = true;
+        defaultTierConfig.reserveFrequency = 0;
+
+        ForTest_JB721TiersHook tiersHook = _initializeHookWithCheckpoints(1);
+
+        // Mint to test checkpoint tracking.
+        uint16[] memory tiersToMint = new uint16[](1);
+        tiersToMint[0] = 1;
+        vm.prank(owner);
+        tiersHook.mintFor(tiersToMint, makeAddr("user"));
+
+        IJB721Checkpoints module = tiersHook.CHECKPOINTS();
+
+        vm.expectRevert(JB721Checkpoints.JB721Checkpoints_Unauthorized.selector);
+        module.onTransfer(address(0), address(1), 1);
+    }
+}

package/test/audit/CodexNemesisRepoFindings.t.sol

@@ -0,0 +1,270 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+import "../utils/UnitTestSetup.sol";
+
+import {IJB721TiersHookStore} from "../../src/interfaces/IJB721TiersHookStore.sol";
+import {JB721TierConfigFlags} from "../../src/structs/JB721TierConfigFlags.sol";
+import {JBSplit} from "@bananapus/core-v6/src/structs/JBSplit.sol";
+
+contract CodexNemesisRepoFindings is UnitTestSetup {
+    address payable internal splitBeneficiary = payable(makeAddr("splitBeneficiary"));
+
+    function _payMetadata(
+        address hookAddress,
+        bool allowOverspending,
+        uint16[] memory tierIds
+    )
+        internal
+        view
+        returns (bytes memory)
+    {
+        bytes[] memory data = new bytes[](1);
+        data[0] = abi.encode(allowOverspending, tierIds);
+        bytes4[] memory ids = new bytes4[](1);
+        ids[0] = metadataHelper.getId("pay", hookAddress);
+        return metadataHelper.createMetadata(ids, data);
+    }
+
+    function _nativeTokenAmount(uint256 value) internal pure returns (JBTokenAmount memory) {
+        return JBTokenAmount({
+            token: JBConstants.NATIVE_TOKEN,
+            value: value,
+            decimals: 18,
+            currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+    }
+
+    function test_payCredits_can_underfund_split_bearing_tier_mints() public {
+        ForTest_JB721TiersHook testHook = _initializeForTestHook(0);
+
+        vm.mockCall(mockJBSplits, abi.encodeWithSelector(IJBSplits.setSplitGroupsOf.selector), abi.encode());
+
+        JBSplit[] memory tierSplits = new JBSplit[](1);
+        tierSplits[0] = JBSplit({
+            preferAddToBalance: false,
+            percent: JBConstants.SPLITS_TOTAL_PERCENT,
+            projectId: 0,
+            beneficiary: splitBeneficiary,
+            lockedUntil: 0,
+            hook: IJBSplitHook(address(0))
+        });
+
+        JB721TierConfig[] memory tierConfigs = new JB721TierConfig[](1);
+        tierConfigs[0] = JB721TierConfig({
+            price: 1 ether,
+            initialSupply: 10,
+            votingUnits: 0,
+            reserveFrequency: 0,
+            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: JBConstants.SPLITS_TOTAL_PERCENT,
+            splits: tierSplits
+        });
+
+        vm.prank(owner);
+        testHook.adjustTiers(tierConfigs, new uint256[](0));
+
+        uint256 groupId = uint256(uint160(address(testHook))) | (uint256(1) << 160);
+        vm.mockCall(
+            mockJBSplits,
+            abi.encodeWithSelector(IJBSplits.splitsOf.selector, projectId, uint256(0), groupId),
+            abi.encode(tierSplits)
+        );
+
+        mockAndExpect(
+            mockJBDirectory,
+            abi.encodeWithSelector(IJBDirectory.isTerminalOf.selector, projectId, mockTerminalAddress),
+            abi.encode(true)
+        );
+
+        vm.prank(mockTerminalAddress);
+        testHook.afterPayRecordedWith(
+            JBAfterPayRecordedContext({
+                payer: beneficiary,
+                projectId: projectId,
+                rulesetId: 0,
+                amount: _nativeTokenAmount(1 ether),
+                forwardedAmount: _nativeTokenAmount(0),
+                weight: 10e18,
+                newlyIssuedTokenCount: 0,
+                beneficiary: beneficiary,
+                hookMetadata: bytes(""),
+                payerMetadata: bytes("")
+            })
+        );
+
+        assertEq(testHook.payCreditsOf(beneficiary), 1 ether, "setup: credits should be seeded");
+
+        uint16[] memory tierIdsToMint = new uint16[](1);
+        tierIdsToMint[0] = 1;
+        bytes memory payerMetadata = _payMetadata(address(testHook), true, tierIdsToMint);
+
+        JBBeforePayRecordedContext memory beforeContext = JBBeforePayRecordedContext({
+            terminal: mockTerminalAddress,
+            payer: beneficiary,
+            amount: _nativeTokenAmount(1),
+            projectId: projectId,
+            rulesetId: 0,
+            beneficiary: beneficiary,
+            weight: 10e18,
+            reservedPercent: 5000,
+            metadata: payerMetadata
+        });
+
+        (uint256 weight, JBPayHookSpecification[] memory specs) = testHook.beforePayRecordedWith(beforeContext);
+
+        assertEq(weight, 0, "only the fresh 1 wei payment is considered for split weight adjustment");
+        assertEq(specs.length, 1);
+        assertEq(specs[0].amount, 1, "split forwarding is capped to the fresh payment, not the credit-backed mint");
+
+        uint256 splitBeneficiaryBalanceBefore = splitBeneficiary.balance;
+        vm.deal(mockTerminalAddress, 1);
+
+        vm.prank(mockTerminalAddress);
+        testHook.afterPayRecordedWith{value: 1}(
+            JBAfterPayRecordedContext({
+                payer: beneficiary,
+                projectId: projectId,
+                rulesetId: 0,
+                amount: _nativeTokenAmount(1),
+                forwardedAmount: _nativeTokenAmount(1),
+                weight: weight,
+                newlyIssuedTokenCount: 0,
+                beneficiary: beneficiary,
+                hookMetadata: specs[0].metadata,
+                payerMetadata: payerMetadata
+            })
+        );
+
+        assertEq(testHook.balanceOf(beneficiary), 1, "beneficiary still receives the split-bearing NFT");
+        assertEq(testHook.payCreditsOf(beneficiary), 1, "stored credits fund essentially the entire mint");
+        assertEq(
+            splitBeneficiary.balance - splitBeneficiaryBalanceBefore,
+            1,
+            "split beneficiary only receives the fresh 1 wei payment instead of the tier's 1 ether split amount"
+        );
+    }
+
+    function test_new_default_reserve_beneficiary_retroactively_dilutes_existing_tiers() public {
+        ForTest_JB721TiersHook testHook = _initializeForTestHook(0);
+
+        JB721TierConfig[] memory initialTier = new JB721TierConfig[](1);
+        initialTier[0] = JB721TierConfig({
+            price: 1 ether,
+            initialSupply: 10,
+            votingUnits: 0,
+            reserveFrequency: 2,
+            reserveBeneficiary: address(0),
+            encodedIPFSUri: bytes32(uint256(0x1111)),
+            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(initialTier, new uint256[](0));
+
+        mockAndExpect(
+            mockJBDirectory,
+            abi.encodeWithSelector(IJBDirectory.isTerminalOf.selector, projectId, mockTerminalAddress),
+            abi.encode(true)
+        );
+
+        uint16[] memory tierIdsToMint = new uint16[](3);
+        tierIdsToMint[0] = 1;
+        tierIdsToMint[1] = 1;
+        tierIdsToMint[2] = 1;
+        bytes memory payerMetadata = _payMetadata(address(testHook), false, tierIdsToMint);
+
+        vm.prank(mockTerminalAddress);
+        testHook.afterPayRecordedWith(
+            JBAfterPayRecordedContext({
+                payer: beneficiary,
+                projectId: projectId,
+                rulesetId: 0,
+                amount: _nativeTokenAmount(3 ether),
+                forwardedAmount: _nativeTokenAmount(0),
+                weight: 10e18,
+                newlyIssuedTokenCount: 0,
+                beneficiary: beneficiary,
+                hookMetadata: bytes(""),
+                payerMetadata: payerMetadata
+            })
+        );
+
+        assertEq(testHook.totalCashOutWeight(), 3 ether, "denominator initially reflects only sold NFTs");
+        assertEq(
+            testHook.STORE().numberOfPendingReservesFor(address(testHook), 1),
+            0,
+            "without a reserve beneficiary the sold tier has no pending reserves"
+        );
+
+        JB721TierConfig[] memory defaultingTier = new JB721TierConfig[](1);
+        defaultingTier[0] = JB721TierConfig({
+            price: 2 ether,
+            initialSupply: 10,
+            votingUnits: 0,
+            reserveFrequency: 1,
+            reserveBeneficiary: owner,
+            encodedIPFSUri: bytes32(uint256(0x2222)),
+            category: 2,
+            discountPercent: 0,
+            flags: JB721TierConfigFlags({
+                allowOwnerMint: false,
+                useReserveBeneficiaryAsDefault: true,
+                transfersPausable: false,
+                useVotingUnits: false,
+                cantBeRemoved: false,
+                cantIncreaseDiscountPercent: false,
+                cantBuyWithCredits: false
+            }),
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+
+        vm.prank(owner);
+        testHook.adjustTiers(defaultingTier, new uint256[](0));
+
+        assertEq(
+            testHook.STORE().reserveBeneficiaryOf(address(testHook), 1),
+            owner,
+            "the new default reserve beneficiary retroactively applies to the older sold tier"
+        );
+        assertEq(
+            testHook.STORE().numberOfPendingReservesFor(address(testHook), 1),
+            2,
+            "the older tier now reports newly created pending reserves from past sales"
+        );
+        assertEq(
+            testHook.totalCashOutWeight(),
+            5 ether,
+            "cash-out denominator is diluted by retroactively created reserves on the existing tier"
+        );
+
+        testHook.mintPendingReservesFor(1, 2);
+
+        assertEq(testHook.balanceOf(owner), 2, "the owner can mint those retroactive reserve NFTs to themselves");
+    }
+}