@bananapus/721-hook-v6 0.0.7 → 0.0.9

package/src/interfaces/IJB721TiersHook.sol

@@ -1,13 +1,10 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import {IJBCashOutHook} from "@bananapus/core-v6/src/interfaces/IJBCashOutHook.sol";
-import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
-import {IJBPayHook} from "@bananapus/core-v6/src/interfaces/IJBPayHook.sol";
 import {IJBPrices} from "@bananapus/core-v6/src/interfaces/IJBPrices.sol";
-import {IJBRulesetDataHook} from "@bananapus/core-v6/src/interfaces/IJBRulesetDataHook.sol";
 import {IJBRulesets} from "@bananapus/core-v6/src/interfaces/IJBRulesets.sol";
 
+import {IJB721Hook} from "./IJB721Hook.sol";
 import {IJB721TiersHookStore} from "./IJB721TiersHookStore.sol";
 import {IJB721TokenUriResolver} from "./IJB721TokenUriResolver.sol";
 import {JB721InitTiersConfig} from "../structs/JB721InitTiersConfig.sol";
@@ -16,7 +13,7 @@ import {JB721TiersHookFlags} from "../structs/JB721TiersHookFlags.sol";
 import {JB721TiersMintReservesConfig} from "../structs/JB721TiersMintReservesConfig.sol";
 import {JB721TiersSetDiscountPercentConfig} from "../structs/JB721TiersSetDiscountPercentConfig.sol";
 
-interface IJB721TiersHook is IJBRulesetDataHook, IJBPayHook, IJBCashOutHook {
+interface IJB721TiersHook is IJB721Hook {
     event AddPayCredits(
         uint256 indexed amount, uint256 indexed newTotalCredits, address indexed account, address caller
     );
@@ -39,18 +36,6 @@ interface IJB721TiersHook is IJBRulesetDataHook, IJBPayHook, IJBCashOutHook {
         uint256 indexed amount, uint256 indexed newTotalCredits, address indexed account, address caller
     );
 
-    /// @notice The directory of terminals and controllers for projects.
-    /// @return The directory contract.
-    function DIRECTORY() external view returns (IJBDirectory);
-
-    /// @notice The ID used when parsing metadata.
-    /// @return The address of the metadata ID target.
-    function METADATA_ID_TARGET() external view returns (address);
-
-    /// @notice The ID of the project that this contract is associated with.
-    /// @return The project ID.
-    function PROJECT_ID() external view returns (uint256);
-
     /// @notice The contract storing and managing project rulesets.
     /// @return The rulesets contract.
     function RULESETS() external view returns (IJBRulesets);

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 {

package/test/unit/pay_Unit.t.sol

@@ -965,7 +965,7 @@ contract Test_afterPayRecorded_Unit is UnitTestSetup {
         vm.prank(terminal);
 
         // Expect a revert for the caller not being a terminal of the project.
-        vm.expectRevert(abi.encodeWithSelector(JB721TiersHook.JB721TiersHook_InvalidPay.selector));
+        vm.expectRevert(abi.encodeWithSelector(JB721Hook.JB721Hook_InvalidPay.selector));
 
         hook.afterPayRecordedWith(
             JBAfterPayRecordedContext({