@bananapus/721-hook-v6 0.0.8 → 0.0.9

package/SKILLS.md

@@ -140,7 +140,7 @@ Each tier has configurable voting power:
 - Splits are registered via `JB721TiersHookLib._setSplitGroupsFor` when tiers with `splits` are added.
 - In `beforePayRecordedWith`, `calculateSplitAmounts` decodes tier IDs from payer metadata, computes `mulDiv(price, splitPercent, SPLITS_TOTAL_PERCENT)` per tier, and returns the total to be forwarded to the hook.
 - In `afterPayRecordedWith`, `distributeAll` distributes forwarded funds to each tier's split group recipients. Leftover after all splits goes back to the project's balance via `addToBalance`.
-- Split recipients can be projects (via `terminal.pay` or `terminal.addToBalance`) or plain addresses (direct ETH transfer or `SafeERC20.safeTransfer`).
+- Split recipients can be projects (via `terminal.pay` or `terminal.addToBalance`) or plain addresses (direct ETH transfer or `SafeERC20.safeTransfer`). Splits with no `projectId` and no `beneficiary` are skipped -- their share stays in the leftover and is routed to the project's own balance via `addToBalanceOf`, preventing a misconfigured split from bricking the payout distribution.
 
 ## Gotchas
 
@@ -160,6 +160,7 @@ Each tier has configurable voting power:
 - The `_update` override in `JB721TiersHook` checks `tier.transfersPausable` and consults the current ruleset's metadata for `transfersPaused`. Transfers to `address(0)` (burns) are never blocked.
 - **IERC2981 declared but not implemented**: `supportsInterface` returns `true` for `IERC2981`, but no `royaltyInfo` function is implemented. Callers querying `royaltyInfo` will get a revert. This appears intentional -- the interface is declared for future extension or to signal capability to marketplaces that may override behavior.
 - **Tier splits**: Each tier can route a percentage of its mint price to configured split recipients. `splitPercent` is out of `JBConstants.SPLITS_TOTAL_PERCENT` (1,000,000,000). Split group IDs are `uint256(uint160(hookAddress)) | (uint256(tierId) << 160)`.
+- **`useReserveBeneficiaryAsDefault` overwrites globally**: Adding a tier with `useReserveBeneficiaryAsDefault: true` silently overwrites `defaultReserveBeneficiaryOf` for ALL existing tiers that lack a tier-specific beneficiary. A `SetDefaultReserveBeneficiary` event is emitted when the default changes.
 - **Removing tiers does not update the sorted list**: `recordRemoveTierIds` only marks tiers in the bitmap. Call `cleanTiers()` afterward to remove them from the iteration sequence.
 - `JB721TiersHookStore` is a **shared singleton** -- all hook instances on the same chain use the same store, keyed by `address(hook)`.
 - The `ERC721` abstract uses `_initialize(name, symbol)` instead of a constructor, making it clone-compatible. The standard `_owners` mapping is `internal` (not `private`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/721-hook-v6",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -17,10 +17,10 @@
     "artifacts": "source ./.env && npx sphinx artifacts --org-id 'ea165b21-7cdc-4d7b-be59-ecdd4c26bee4' --project-name 'nana-721-hook-v6'"
   },
   "dependencies": {
-    "@bananapus/address-registry-v6": "^0.0.3",
-    "@bananapus/core-v6": "^0.0.5",
-    "@bananapus/ownable-v6": "^0.0.4",
-    "@bananapus/permission-ids-v6": "^0.0.3",
+    "@bananapus/address-registry-v6": "^0.0.4",
+    "@bananapus/core-v6": "^0.0.9",
+    "@bananapus/ownable-v6": "^0.0.5",
+    "@bananapus/permission-ids-v6": "^0.0.4",
     "@openzeppelin/contracts": "5.2.0",
     "@prb/math": "^4.1.0",
     "solady": "^0.1.8"

package/src/JB721TiersHookStore.sol

@@ -763,6 +763,10 @@ contract JB721TiersHookStore is IJB721TiersHookStore {
     }
 
     /// @notice Record newly added tiers.
+    /// @dev WARNING: If any tier in `tiersToAdd` has `useReserveBeneficiaryAsDefault` set to `true`, its
+    /// `reserveBeneficiary` will overwrite the hook's global `defaultReserveBeneficiaryOf`. This affects ALL existing
+    /// tiers that do not have a tier-specific reserve beneficiary set via `_reserveBeneficiaryOf`. Callers should be
+    /// aware of this side effect when using `adjustTiers` to add new tiers.
     /// @param tiersToAdd The tiers to add.
     /// @return tierIds The IDs of the tiers being added.
     function recordAddTiers(JB721TierConfig[] calldata tiersToAdd)
@@ -884,8 +888,12 @@ contract JB721TiersHookStore is IJB721TiersHookStore {
             // Set the reserve beneficiary if needed.
             if (tierToAdd.reserveBeneficiary != address(0) && tierToAdd.reserveFrequency != 0) {
                 if (tierToAdd.useReserveBeneficiaryAsDefault) {
+                    // WARNING: This overwrites the global default for ALL tiers without a tier-specific beneficiary.
                     if (defaultReserveBeneficiaryOf[msg.sender] != tierToAdd.reserveBeneficiary) {
                         defaultReserveBeneficiaryOf[msg.sender] = tierToAdd.reserveBeneficiary;
+                        emit SetDefaultReserveBeneficiary({
+                            hook: msg.sender, newBeneficiary: tierToAdd.reserveBeneficiary, caller: msg.sender
+                        });
                     }
                 } else {
                     _reserveBeneficiaryOf[msg.sender][tierId] = tierToAdd.reserveBeneficiary;

package/src/interfaces/IJB721TiersHookStore.sol

@@ -9,6 +9,13 @@ import {JB721TiersHookFlags} from "../structs/JB721TiersHookFlags.sol";
 interface IJB721TiersHookStore {
     event CleanTiers(address indexed hook, address caller);
 
+    /// @notice Emitted when the default reserve beneficiary is changed.
+    /// @dev This affects ALL tiers that do not have a tier-specific reserve beneficiary set.
+    /// @param hook The 721 contract whose default reserve beneficiary was changed.
+    /// @param newBeneficiary The new default reserve beneficiary address.
+    /// @param caller The address that triggered the change.
+    event SetDefaultReserveBeneficiary(address indexed hook, address indexed newBeneficiary, address caller);
+
     /// @notice Get the number of NFTs that the specified address owns from the specified 721 contract.
     /// @param hook The 721 contract to get the balance within.
     /// @param owner The address to check the balance of.

package/src/libraries/JB721TiersHookLib.sol

@@ -17,6 +17,7 @@ import {JBSplitGroup} from "@bananapus/core-v6/src/structs/JBSplitGroup.sol";
 
 import {IJB721TiersHookStore} from "../interfaces/IJB721TiersHookStore.sol";
 import {IJB721TokenUriResolver} from "../interfaces/IJB721TokenUriResolver.sol";
+import {JB721Tier} from "../structs/JB721Tier.sol";
 import {JB721TierConfig} from "../structs/JB721TierConfig.sol";
 import {JBIpfsDecoder} from "./JBIpfsDecoder.sol";
 
@@ -52,6 +53,7 @@ library JB721TiersHookLib {
             for (uint256 i; i < tierIdsToRemove.length; i++) {
                 emit RemoveTier({tierId: tierIdsToRemove[i], caller: caller});
             }
+            // slither-disable-next-line reentrancy-events
             store.recordRemoveTierIds(tierIdsToRemove);
         }
 
@@ -141,12 +143,10 @@ library JB721TiersHookLib {
 
         for (uint256 i; i < tierIdsToMint.length; i++) {
             // slither-disable-next-line calls-loop
-            uint256 splitPercent = store.tierOf(hook, tierIdsToMint[i], false).splitPercent;
-            if (splitPercent != 0) {
-                // slither-disable-next-line calls-loop
-                uint256 price = store.tierOf(hook, tierIdsToMint[i], false).price;
+            JB721Tier memory tier = store.tierOf(hook, tierIdsToMint[i], false);
+            if (tier.splitPercent != 0) {
                 splitTierIds[splitTierCount] = tierIdsToMint[i];
-                splitAmounts[splitTierCount] = mulDiv(price, splitPercent, JBConstants.SPLITS_TOTAL_PERCENT);
+                splitAmounts[splitTierCount] = mulDiv(tier.price, tier.splitPercent, JBConstants.SPLITS_TOTAL_PERCENT);
                 totalSplitAmount += splitAmounts[splitTierCount];
                 splitTierCount++;
             }
@@ -237,9 +237,13 @@ library JB721TiersHookLib {
         for (uint256 j; j < tierSplits.length; j++) {
             uint256 payoutAmount = mulDiv(amount, tierSplits[j].percent, leftoverPercentage);
             if (payoutAmount != 0) {
-                _sendPayoutToSplit(directory, tierSplits[j], token, payoutAmount, isNativeToken);
-                unchecked {
-                    leftoverAmount -= payoutAmount;
+                // Only subtract from leftover if the split has a valid recipient.
+                // Splits with no projectId and no beneficiary are skipped — their share
+                // stays in leftoverAmount and is added to the project's balance below.
+                if (_sendPayoutToSplit(directory, tierSplits[j], token, payoutAmount, isNativeToken)) {
+                    unchecked {
+                        leftoverAmount -= payoutAmount;
+                    }
                 }
             }
             unchecked {
@@ -252,6 +256,9 @@ library JB721TiersHookLib {
         }
     }
 
+    /// @notice Sends a payout to a split recipient.
+    /// @return sent Whether the funds were actually sent. Returns false if the split has no valid recipient
+    /// (no projectId and no beneficiary), so the caller can route the funds elsewhere.
     function _sendPayoutToSplit(
         IJBDirectory directory,
         JBSplit memory split,
@@ -260,17 +267,19 @@ library JB721TiersHookLib {
         bool isNativeToken
     )
         private
+        returns (bool sent)
     {
         if (split.projectId != 0) {
             // slither-disable-next-line calls-loop
             IJBTerminal terminal = directory.primaryTerminalOf(split.projectId, token);
-            if (address(terminal) == address(0)) return;
+            if (address(terminal) == address(0)) return false;
 
             if (split.preferAddToBalance) {
                 _terminalAddToBalance(terminal, split.projectId, token, amount, isNativeToken);
             } else {
                 _terminalPay(terminal, split.projectId, token, amount, split.beneficiary, isNativeToken);
             }
+            return true;
         } else if (split.beneficiary != address(0)) {
             if (isNativeToken) {
                 // slither-disable-next-line arbitrary-send-eth,calls-loop
@@ -279,7 +288,10 @@ library JB721TiersHookLib {
             } else {
                 SafeERC20.safeTransfer(IERC20(token), split.beneficiary, amount);
             }
+            return true;
         }
+        // No projectId and no beneficiary — return false so the funds go to the project's balance.
+        return false;
     }
 
     function _addToBalance(

package/src/structs/JB721TierConfig.sol

@@ -18,7 +18,9 @@ import {JBSplit} from "@bananapus/core-v6/src/structs/JBSplit.sol";
 /// @custom:member allowOwnerMint A boolean indicating whether the contract's owner can mint NFTs from this tier
 /// on-demand.
 /// @custom:member useReserveBeneficiaryAsDefault A boolean indicating whether this tier's `reserveBeneficiary` should
-/// be stored as the default beneficiary for all tiers.
+/// be stored as the default beneficiary for all tiers. WARNING: Setting this to `true` overwrites the global
+/// `defaultReserveBeneficiaryOf` for the hook, which affects ALL existing tiers that do not have a tier-specific
+/// reserve beneficiary. Use with caution when calling `adjustTiers` on hooks with existing tiers.
 /// @custom:member transfersPausable A boolean indicating whether transfers for NFTs in tier can be paused.
 /// @custom:member useVotingUnits A boolean indicating whether the `votingUnits` should be used to calculate voting
 /// power. If `useVotingUnits` is false, voting power is based on the tier's price.

package/test/regression/L34_ReserveBeneficiaryOverwrite.t.sol

@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import "../utils/UnitTestSetup.sol";
+import {IJB721TiersHookStore} from "../../src/interfaces/IJB721TiersHookStore.sol";
+
+/// @notice Regression test for L-34: defaultReserveBeneficiaryOf is globally overwritten when adding a tier with
+/// useReserveBeneficiaryAsDefault=true.
+contract Test_L34_ReserveBeneficiaryOverwrite is UnitTestSetup {
+    using stdStorage for StdStorage;
+
+    address alice = makeAddr("alice");
+    address bob = makeAddr("bob");
+
+    /// @notice Verify that adding a tier with useReserveBeneficiaryAsDefault=true overwrites the global default
+    /// and emits the SetDefaultReserveBeneficiary event.
+    function test_addTierWithDefaultBeneficiary_overwritesGlobal() public {
+        ForTest_JB721TiersHook testHook = _initializeForTestHook(0);
+        IJB721TiersHookStore hookStore = testHook.STORE();
+
+        // Add tier 1: alice as default reserve beneficiary.
+        JB721TierConfig[] memory tier1Configs = new JB721TierConfig[](1);
+        tier1Configs[0].price = 1 ether;
+        tier1Configs[0].initialSupply = uint32(100);
+        tier1Configs[0].category = uint24(1);
+        tier1Configs[0].encodedIPFSUri = bytes32(uint256(0x1234));
+        tier1Configs[0].reserveFrequency = 5;
+        tier1Configs[0].reserveBeneficiary = alice;
+        tier1Configs[0].useReserveBeneficiaryAsDefault = true;
+
+        vm.prank(address(testHook));
+        uint256[] memory tier1Ids = hookStore.recordAddTiers(tier1Configs);
+
+        // Verify alice is the default reserve beneficiary.
+        assertEq(hookStore.defaultReserveBeneficiaryOf(address(testHook)), alice);
+
+        // Verify tier 1 uses alice as its reserve beneficiary (via the default).
+        assertEq(hookStore.reserveBeneficiaryOf(address(testHook), tier1Ids[0]), alice);
+
+        // Add tier 2: no useReserveBeneficiaryAsDefault, with a per-tier beneficiary.
+        JB721TierConfig[] memory tier2Configs = new JB721TierConfig[](1);
+        tier2Configs[0].price = 2 ether;
+        tier2Configs[0].initialSupply = uint32(100);
+        tier2Configs[0].category = uint24(2);
+        tier2Configs[0].encodedIPFSUri = bytes32(uint256(0x5678));
+        tier2Configs[0].reserveFrequency = 5;
+        tier2Configs[0].reserveBeneficiary = bob;
+        tier2Configs[0].useReserveBeneficiaryAsDefault = false;
+
+        vm.prank(address(testHook));
+        uint256[] memory tier2Ids = hookStore.recordAddTiers(tier2Configs);
+
+        // Default should still be alice.
+        assertEq(hookStore.defaultReserveBeneficiaryOf(address(testHook)), alice);
+
+        // Tier 2 should use bob (tier-specific).
+        assertEq(hookStore.reserveBeneficiaryOf(address(testHook), tier2Ids[0]), bob);
+
+        // Now add tier 3: bob as the NEW default reserve beneficiary.
+        // This should overwrite the default, affecting tier 1 which relies on the default.
+        JB721TierConfig[] memory tier3Configs = new JB721TierConfig[](1);
+        tier3Configs[0].price = 3 ether;
+        tier3Configs[0].initialSupply = uint32(100);
+        tier3Configs[0].category = uint24(3);
+        tier3Configs[0].encodedIPFSUri = bytes32(uint256(0x9ABC));
+        tier3Configs[0].reserveFrequency = 5;
+        tier3Configs[0].reserveBeneficiary = bob;
+        tier3Configs[0].useReserveBeneficiaryAsDefault = true;
+
+        vm.prank(address(testHook));
+        uint256[] memory tier3Ids = hookStore.recordAddTiers(tier3Configs);
+
+        // Default should now be bob.
+        assertEq(hookStore.defaultReserveBeneficiaryOf(address(testHook)), bob);
+
+        // Tier 1 should now resolve to bob (the new default), NOT alice.
+        // This is the documented global overwrite behavior.
+        assertEq(hookStore.reserveBeneficiaryOf(address(testHook), tier1Ids[0]), bob);
+
+        // Tier 2 should still use bob (tier-specific, unaffected by default change).
+        assertEq(hookStore.reserveBeneficiaryOf(address(testHook), tier2Ids[0]), bob);
+
+        // Tier 3 should also resolve to bob (via the default).
+        assertEq(hookStore.reserveBeneficiaryOf(address(testHook), tier3Ids[0]), bob);
+    }
+
+    /// @notice Verify that the SetDefaultReserveBeneficiary event is emitted when the default changes.
+    function test_addTierWithDefaultBeneficiary_emitsEvent() public {
+        ForTest_JB721TiersHook testHook = _initializeForTestHook(0);
+        IJB721TiersHookStore hookStore = testHook.STORE();
+
+        JB721TierConfig[] memory tierConfigs = new JB721TierConfig[](1);
+        tierConfigs[0].price = 1 ether;
+        tierConfigs[0].initialSupply = uint32(100);
+        tierConfigs[0].category = uint24(1);
+        tierConfigs[0].encodedIPFSUri = bytes32(uint256(0x1234));
+        tierConfigs[0].reserveFrequency = 5;
+        tierConfigs[0].reserveBeneficiary = alice;
+        tierConfigs[0].useReserveBeneficiaryAsDefault = true;
+
+        // Expect the SetDefaultReserveBeneficiary event.
+        vm.expectEmit(true, true, false, true, address(hookStore));
+        emit IJB721TiersHookStore.SetDefaultReserveBeneficiary({
+            hook: address(testHook), newBeneficiary: alice, caller: address(testHook)
+        });
+
+        vm.prank(address(testHook));
+        hookStore.recordAddTiers(tierConfigs);
+    }
+
+    /// @notice Verify that no event is emitted when the beneficiary is already the same.
+    function test_addTierWithSameDefaultBeneficiary_noEvent() public {
+        ForTest_JB721TiersHook testHook = _initializeForTestHook(0);
+        IJB721TiersHookStore hookStore = testHook.STORE();
+
+        // First, set alice as the default.
+        JB721TierConfig[] memory tier1Configs = new JB721TierConfig[](1);
+        tier1Configs[0].price = 1 ether;
+        tier1Configs[0].initialSupply = uint32(100);
+        tier1Configs[0].category = uint24(1);
+        tier1Configs[0].encodedIPFSUri = bytes32(uint256(0x1234));
+        tier1Configs[0].reserveFrequency = 5;
+        tier1Configs[0].reserveBeneficiary = alice;
+        tier1Configs[0].useReserveBeneficiaryAsDefault = true;
+
+        vm.prank(address(testHook));
+        hookStore.recordAddTiers(tier1Configs);
+
+        // Now add another tier with the same default — no event should be emitted.
+        JB721TierConfig[] memory tier2Configs = new JB721TierConfig[](1);
+        tier2Configs[0].price = 2 ether;
+        tier2Configs[0].initialSupply = uint32(100);
+        tier2Configs[0].category = uint24(2);
+        tier2Configs[0].encodedIPFSUri = bytes32(uint256(0x5678));
+        tier2Configs[0].reserveFrequency = 5;
+        tier2Configs[0].reserveBeneficiary = alice;
+        tier2Configs[0].useReserveBeneficiaryAsDefault = true;
+
+        // Record the logs to verify no SetDefaultReserveBeneficiary event is emitted.
+        vm.recordLogs();
+
+        vm.prank(address(testHook));
+        hookStore.recordAddTiers(tier2Configs);
+
+        Vm.Log[] memory logs = vm.getRecordedLogs();
+        for (uint256 i; i < logs.length; i++) {
+            // SetDefaultReserveBeneficiary event signature.
+            assertTrue(
+                logs[i].topics[0] != keccak256("SetDefaultReserveBeneficiary(address,address,address)"),
+                "SetDefaultReserveBeneficiary should not be emitted when beneficiary unchanged"
+            );
+        }
+    }
+}

package/test/regression/L35_CacheTierLookup.t.sol

@@ -0,0 +1,188 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import "../utils/UnitTestSetup.sol";
+import {IJB721TiersHookStore} from "../../src/interfaces/IJB721TiersHookStore.sol";
+import {JB721TiersHookLib} from "../../src/libraries/JB721TiersHookLib.sol";
+
+/// @notice Regression test for L-35: calculateSplitAmounts cached the tierOf result to avoid a duplicate external call.
+/// Verifies that the cached tier lookup returns the same split amounts as reading price and splitPercent individually.
+contract Test_L35_CacheTierLookup is UnitTestSetup {
+    using stdStorage for StdStorage;
+
+    /// @notice Verify that calculateSplitAmounts returns correct per-tier amounts when multiple tiers have different
+    /// prices and split percentages. This exercises the cached `tier` variable introduced by L-35.
+    function test_calculateSplitAmounts_multiTier_correctAmounts() public {
+        ForTest_JB721TiersHook testHook = _initializeForTestHook(0);
+        IJB721TiersHookStore hookStore = testHook.STORE();
+
+        // Add 3 tiers with different prices and split percents.
+        JB721TierConfig[] memory tierConfigs = new JB721TierConfig[](3);
+
+        // Tier A: 1 ETH, 25% split -> 0.25 ETH
+        tierConfigs[0].price = 1 ether;
+        tierConfigs[0].initialSupply = uint32(100);
+        tierConfigs[0].category = uint24(1);
+        tierConfigs[0].encodedIPFSUri = bytes32(uint256(0x1111));
+        tierConfigs[0].splitPercent = 250_000_000; // 25%
+
+        // Tier B: 2 ETH, 50% split -> 1 ETH
+        tierConfigs[1].price = 2 ether;
+        tierConfigs[1].initialSupply = uint32(100);
+        tierConfigs[1].category = uint24(2);
+        tierConfigs[1].encodedIPFSUri = bytes32(uint256(0x2222));
+        tierConfigs[1].splitPercent = 500_000_000; // 50%
+
+        // Tier C: 0.5 ETH, 100% split -> 0.5 ETH
+        tierConfigs[2].price = 0.5 ether;
+        tierConfigs[2].initialSupply = uint32(100);
+        tierConfigs[2].category = uint24(3);
+        tierConfigs[2].encodedIPFSUri = bytes32(uint256(0x3333));
+        tierConfigs[2].splitPercent = 1_000_000_000; // 100%
+
+        vm.prank(address(testHook));
+        uint256[] memory tierIds = hookStore.recordAddTiers(tierConfigs);
+
+        // Build payer metadata requesting all 3 tiers.
+        uint16[] memory mintIds = new uint16[](3);
+        mintIds[0] = uint16(tierIds[0]);
+        mintIds[1] = uint16(tierIds[1]);
+        mintIds[2] = uint16(tierIds[2]);
+        bytes memory payerMetadata = _buildPayerMetadata(address(testHook), mintIds);
+
+        JBBeforePayRecordedContext memory context = JBBeforePayRecordedContext({
+            terminal: mockTerminalAddress,
+            payer: beneficiary,
+            amount: JBTokenAmount({
+                token: JBConstants.NATIVE_TOKEN,
+                value: 3.5 ether,
+                decimals: 18,
+                currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+            }),
+            projectId: projectId,
+            rulesetId: 0,
+            beneficiary: beneficiary,
+            weight: 10e18,
+            reservedPercent: 5000,
+            metadata: payerMetadata
+        });
+
+        (, JBPayHookSpecification[] memory specs) = testHook.beforePayRecordedWith(context);
+
+        // Total split = 0.25 + 1.0 + 0.5 = 1.75 ETH
+        assertEq(specs[0].amount, 1.75 ether, "Total split amount should be 1.75 ETH");
+    }
+
+    /// @notice Verify that a tier with splitPercent == 0 contributes nothing to the total, even when cached.
+    function test_calculateSplitAmounts_zeroSplitSkipped() public {
+        ForTest_JB721TiersHook testHook = _initializeForTestHook(0);
+        IJB721TiersHookStore hookStore = testHook.STORE();
+
+        // Tier A: 1 ETH, 50% split
+        // Tier B: 3 ETH, 0% split (should be skipped)
+        JB721TierConfig[] memory tierConfigs = new JB721TierConfig[](2);
+        tierConfigs[0].price = 1 ether;
+        tierConfigs[0].initialSupply = uint32(100);
+        tierConfigs[0].category = uint24(1);
+        tierConfigs[0].encodedIPFSUri = bytes32(uint256(0xAAAA));
+        tierConfigs[0].splitPercent = 500_000_000; // 50%
+
+        tierConfigs[1].price = 3 ether;
+        tierConfigs[1].initialSupply = uint32(100);
+        tierConfigs[1].category = uint24(2);
+        tierConfigs[1].encodedIPFSUri = bytes32(uint256(0xBBBB));
+        tierConfigs[1].splitPercent = 0; // 0%
+
+        vm.prank(address(testHook));
+        uint256[] memory tierIds = hookStore.recordAddTiers(tierConfigs);
+
+        uint16[] memory mintIds = new uint16[](2);
+        mintIds[0] = uint16(tierIds[0]);
+        mintIds[1] = uint16(tierIds[1]);
+        bytes memory payerMetadata = _buildPayerMetadata(address(testHook), mintIds);
+
+        JBBeforePayRecordedContext memory context = JBBeforePayRecordedContext({
+            terminal: mockTerminalAddress,
+            payer: beneficiary,
+            amount: JBTokenAmount({
+                token: JBConstants.NATIVE_TOKEN,
+                value: 4 ether,
+                decimals: 18,
+                currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+            }),
+            projectId: projectId,
+            rulesetId: 0,
+            beneficiary: beneficiary,
+            weight: 10e18,
+            reservedPercent: 5000,
+            metadata: payerMetadata
+        });
+
+        (, JBPayHookSpecification[] memory specs) = testHook.beforePayRecordedWith(context);
+
+        // Only tier A contributes: 1 ETH * 50% = 0.5 ETH
+        assertEq(specs[0].amount, 0.5 ether, "Only non-zero split tiers should contribute");
+    }
+
+    /// @notice Verify that duplicate tier IDs in metadata produce correct cumulative split amounts.
+    /// The cached tier lookup must handle the same tier appearing multiple times.
+    function test_calculateSplitAmounts_duplicateTierIds() public {
+        ForTest_JB721TiersHook testHook = _initializeForTestHook(0);
+        IJB721TiersHookStore hookStore = testHook.STORE();
+
+        // Single tier: 1 ETH, 30% split
+        JB721TierConfig[] memory tierConfigs = new JB721TierConfig[](1);
+        tierConfigs[0].price = 1 ether;
+        tierConfigs[0].initialSupply = uint32(100);
+        tierConfigs[0].category = uint24(1);
+        tierConfigs[0].encodedIPFSUri = bytes32(uint256(0xCCCC));
+        tierConfigs[0].splitPercent = 300_000_000; // 30%
+
+        vm.prank(address(testHook));
+        uint256[] memory tierIds = hookStore.recordAddTiers(tierConfigs);
+
+        // Request the same tier twice in metadata.
+        uint16[] memory mintIds = new uint16[](2);
+        mintIds[0] = uint16(tierIds[0]);
+        mintIds[1] = uint16(tierIds[0]);
+        bytes memory payerMetadata = _buildPayerMetadata(address(testHook), mintIds);
+
+        JBBeforePayRecordedContext memory context = JBBeforePayRecordedContext({
+            terminal: mockTerminalAddress,
+            payer: beneficiary,
+            amount: JBTokenAmount({
+                token: JBConstants.NATIVE_TOKEN,
+                value: 2 ether,
+                decimals: 18,
+                currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+            }),
+            projectId: projectId,
+            rulesetId: 0,
+            beneficiary: beneficiary,
+            weight: 10e18,
+            reservedPercent: 5000,
+            metadata: payerMetadata
+        });
+
+        (, JBPayHookSpecification[] memory specs) = testHook.beforePayRecordedWith(context);
+
+        // 2 x (1 ETH * 30%) = 0.6 ETH
+        assertEq(specs[0].amount, 0.6 ether, "Duplicate tier IDs should each contribute their split amount");
+    }
+
+    // Helper: build payer metadata for tier IDs.
+    function _buildPayerMetadata(
+        address hookAddress,
+        uint16[] memory tierIdsToMint
+    )
+        internal
+        view
+        returns (bytes memory)
+    {
+        bytes[] memory data = new bytes[](1);
+        data[0] = abi.encode(false, tierIdsToMint);
+        bytes4[] memory ids = new bytes4[](1);
+        ids[0] = metadataHelper.getId("pay", hookAddress);
+        return metadataHelper.createMetadata(ids, data);
+    }
+}

package/test/regression/L36_SplitNoBeneficiary.t.sol

@@ -0,0 +1,146 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import "../utils/UnitTestSetup.sol";
+import {IJB721TiersHookStore} from "../../src/interfaces/IJB721TiersHookStore.sol";
+import {JB721TiersHookLib} from "../../src/libraries/JB721TiersHookLib.sol";
+import {JBSplit} from "@bananapus/core-v6/src/structs/JBSplit.sol";
+import {IJBSplitHook} from "@bananapus/core-v6/src/interfaces/IJBSplitHook.sol";
+import {IJBSplits} from "@bananapus/core-v6/src/interfaces/IJBSplits.sol";
+import {IJBController} from "@bananapus/core-v6/src/interfaces/IJBController.sol";
+import {IJBTerminal} from "@bananapus/core-v6/src/interfaces/IJBTerminal.sol";
+
+/// @notice Regression test for L-36: Split with no beneficiary and no projectId should route funds to the project's
+/// balance instead of silently dropping them.
+contract Test_L36_SplitNoBeneficiary is UnitTestSetup {
+    using stdStorage for StdStorage;
+
+    address mockSplits = makeAddr("mockSplits");
+    address mockProjectTerminal = makeAddr("mockProjectTerminal");
+
+    function setUp() public override {
+        super.setUp();
+        vm.etch(mockSplits, new bytes(0x69));
+        vm.etch(mockProjectTerminal, new bytes(0x69));
+    }
+
+    /// @notice Verify that a split with projectId==0 and beneficiary==address(0) routes funds to the project's
+    /// balance.
+    function test_splitWithNoBeneficiary_routesToProjectBalance() public {
+        ForTest_JB721TiersHook testHook = _initializeForTestHook(0);
+        IJB721TiersHookStore hookStore = testHook.STORE();
+
+        // Add a tier with 50% split.
+        JB721TierConfig[] memory tierConfigs = new JB721TierConfig[](1);
+        tierConfigs[0].price = 1 ether;
+        tierConfigs[0].initialSupply = uint32(100);
+        tierConfigs[0].category = uint24(1);
+        tierConfigs[0].encodedIPFSUri = bytes32(uint256(0x1234));
+        tierConfigs[0].splitPercent = 500_000_000; // 50%
+
+        vm.prank(address(testHook));
+        uint256[] memory tierIds = hookStore.recordAddTiers(tierConfigs);
+
+        // Mock directory checks.
+        mockAndExpect(
+            address(mockJBDirectory),
+            abi.encodeWithSelector(IJBDirectory.isTerminalOf.selector, projectId, mockTerminalAddress),
+            abi.encode(true)
+        );
+        mockAndExpect(
+            address(mockJBDirectory),
+            abi.encodeWithSelector(IJBDirectory.controllerOf.selector, projectId),
+            abi.encode(mockJBController)
+        );
+        mockAndExpect(mockJBController, abi.encodeWithSelector(IJBController.SPLITS.selector), abi.encode(mockSplits));
+
+        // Mock splits: a split with projectId==0 and beneficiary==address(0).
+        JBSplit[] memory splits = new JBSplit[](1);
+        splits[0] = JBSplit({
+            percent: uint32(JBConstants.SPLITS_TOTAL_PERCENT),
+            projectId: 0,
+            beneficiary: payable(address(0)),
+            preferAddToBalance: false,
+            lockedUntil: 0,
+            hook: IJBSplitHook(address(0))
+        });
+
+        uint256 groupId = uint256(uint160(address(testHook))) | (uint256(tierIds[0]) << 160);
+        mockAndExpect(
+            mockSplits, abi.encodeWithSelector(IJBSplits.splitsOf.selector, projectId, 0, groupId), abi.encode(splits)
+        );
+
+        // Mock the project's primary terminal for addToBalanceOf (this is the fallback for no-recipient splits).
+        mockAndExpect(
+            address(mockJBDirectory),
+            abi.encodeWithSelector(IJBDirectory.primaryTerminalOf.selector, projectId, JBConstants.NATIVE_TOKEN),
+            abi.encode(mockProjectTerminal)
+        );
+
+        // Expect addToBalanceOf to be called on the project's terminal with the split amount (0.5 ether).
+        vm.expectCall(
+            mockProjectTerminal,
+            0.5 ether,
+            abi.encodeWithSelector(
+                IJBTerminal.addToBalanceOf.selector, projectId, JBConstants.NATIVE_TOKEN, 0.5 ether, false, "", ""
+            )
+        );
+        // Mock the addToBalanceOf call to succeed.
+        vm.mockCall(mockProjectTerminal, abi.encodeWithSelector(IJBTerminal.addToBalanceOf.selector), abi.encode());
+
+        // Build payer metadata.
+        uint16[] memory mintIds = new uint16[](1);
+        mintIds[0] = uint16(tierIds[0]);
+        bytes memory payerMetadata = _buildPayerMetadata(address(testHook), mintIds);
+
+        // Build hook metadata (per-tier split breakdown from beforePayRecordedWith).
+        uint16[] memory splitTierIds = new uint16[](1);
+        splitTierIds[0] = uint16(tierIds[0]);
+        uint256[] memory splitAmounts = new uint256[](1);
+        splitAmounts[0] = 0.5 ether;
+
+        JBAfterPayRecordedContext memory payContext = JBAfterPayRecordedContext({
+            payer: beneficiary,
+            projectId: projectId,
+            rulesetId: 0,
+            amount: JBTokenAmount({
+                token: JBConstants.NATIVE_TOKEN,
+                value: 1 ether,
+                decimals: 18,
+                currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+            }),
+            forwardedAmount: JBTokenAmount({
+                token: JBConstants.NATIVE_TOKEN,
+                value: 0.5 ether,
+                decimals: 18,
+                currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+            }),
+            weight: 10e18,
+            newlyIssuedTokenCount: 0,
+            beneficiary: beneficiary,
+            hookMetadata: abi.encode(splitTierIds, splitAmounts),
+            payerMetadata: payerMetadata
+        });
+
+        vm.deal(mockTerminalAddress, 1 ether);
+        vm.prank(mockTerminalAddress);
+        // Should NOT revert — funds should be routed to the project's balance.
+        testHook.afterPayRecordedWith{value: 0.5 ether}(payContext);
+    }
+
+    // Helper: build payer metadata for tier IDs.
+    function _buildPayerMetadata(
+        address hookAddress,
+        uint16[] memory tierIdsToMint
+    )
+        internal
+        view
+        returns (bytes memory)
+    {
+        bytes[] memory data = new bytes[](1);
+        data[0] = abi.encode(false, tierIdsToMint);
+        bytes4[] memory ids = new bytes4[](1);
+        ids[0] = metadataHelper.getId("pay", hookAddress);
+        return metadataHelper.createMetadata(ids, data);
+    }
+}

package/test/unit/M6_TierSupplyCheck.t.sol

@@ -4,7 +4,7 @@ pragma solidity 0.8.26;
 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.
+/// @notice Tests that the supply check accounts 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 {