@bananapus/core-v6 0.0.1

package/test/units/static/JBSplits/TestSetSplitGroupsOf.sol

@@ -0,0 +1,370 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBSplitsSetup} from "./JBSplitsSetup.sol";
+
+contract TestSetSplitGroupsOf_Local is JBSplitsSetup {
+    address _notThis = makeAddr("notThis");
+    address payable _bene = payable(makeAddr("guy"));
+    uint64 _projectId = 1;
+    uint256 _rulesetId = block.timestamp;
+
+    function setUp() public {
+        super.splitsSetup();
+    }
+
+    function test_WhenCallerIsNotController() external {
+        // it will revert with CONTROLLER_UNAUTHORIZED
+
+        // data for call
+        JBSplitGroup[] memory _splitsGroup = new JBSplitGroup[](1);
+        JBSplit[] memory _splitsArray = new JBSplit[](1);
+
+        // Set up a payout split recipient.
+        _splitsArray[0] = JBSplit({
+            preferAddToBalance: false,
+            percent: JBConstants.SPLITS_TOTAL_PERCENT / 2,
+            projectId: _projectId,
+            beneficiary: _bene,
+            lockedUntil: 0,
+            hook: IJBSplitHook(address(0))
+        });
+
+        // outer structure
+        _splitsGroup[0] = JBSplitGroup({groupId: 0, splits: _splitsArray});
+
+        // mock the directory controllerOf call
+        bytes memory _controllerCall = abi.encodeCall(IJBDirectory.controllerOf, (1));
+        bytes memory _return = abi.encode(_notThis);
+        mockExpect(address(directory), _controllerCall, _return);
+
+        // not controller so revert
+        vm.expectRevert(abi.encodeWithSelector(JBControlled.JBControlled_ControllerUnauthorized.selector, _notThis));
+        _splits.setSplitGroupsOf(_projectId, _rulesetId, _splitsGroup);
+    }
+
+    modifier whenCallerIsController() {
+        // mock the directory controllerOf call
+        bytes memory _controllerCall = abi.encodeCall(IJBDirectory.controllerOf, (1));
+        bytes memory _return = abi.encode(address(this));
+        mockExpect(address(directory), _controllerCall, _return);
+        _;
+    }
+
+    function test_GivenPreviouslyLockedSplitsAreNotIncluded() external whenCallerIsController {
+        // it will revert with PREVIOUS_LOCKED_SPLITS_NOT_INCLUDED
+
+        // data for first call to set locked splits
+        JBSplitGroup[] memory _splitsGroup = new JBSplitGroup[](1);
+        JBSplit[] memory _splitsArray = new JBSplit[](1);
+
+        // Set up a payout split recipient.
+        _splitsArray[0] = JBSplit({
+            preferAddToBalance: false,
+            percent: JBConstants.SPLITS_TOTAL_PERCENT / 2,
+            projectId: _projectId,
+            beneficiary: _bene,
+            lockedUntil: uint48(block.timestamp + 100),
+            hook: IJBSplitHook(address(0))
+        });
+
+        // outer structure
+        _splitsGroup[0] = JBSplitGroup({groupId: 0, splits: _splitsArray});
+
+        _splits.setSplitGroupsOf(_projectId, _rulesetId, _splitsGroup);
+
+        // Re-set up a payout split recipient.
+        _splitsArray[0] = JBSplit({
+            preferAddToBalance: false,
+            percent: JBConstants.SPLITS_TOTAL_PERCENT / 2,
+            projectId: _projectId,
+            beneficiary: _bene,
+            lockedUntil: 0,
+            hook: IJBSplitHook(address(0))
+        });
+
+        // outer structure
+        _splitsGroup[0] = JBSplitGroup({groupId: 0, splits: _splitsArray});
+
+        vm.expectRevert(
+            abi.encodeWithSelector(JBSplits.JBSplits_PreviousLockedSplitsNotIncluded.selector, _projectId, _rulesetId)
+        );
+        _splits.setSplitGroupsOf(_projectId, _rulesetId, _splitsGroup);
+    }
+
+    function test_GivenAnyConfiguredSplitPercentIsZero() external whenCallerIsController {
+        // it will revert with INVALID_SPLIT_PERCENT
+
+        // data for call to set invalid splits
+        JBSplitGroup[] memory _splitsGroup = new JBSplitGroup[](1);
+        JBSplit[] memory _splitsArray = new JBSplit[](1);
+
+        // Set up a payout split recipient.
+        _splitsArray[0] = JBSplit({
+            preferAddToBalance: false,
+            // invalid percent
+            percent: 0,
+            projectId: _projectId,
+            beneficiary: _bene,
+            lockedUntil: 0,
+            hook: IJBSplitHook(address(0))
+        });
+
+        // outer structure
+        _splitsGroup[0] = JBSplitGroup({groupId: 0, splits: _splitsArray});
+
+        vm.expectRevert(JBSplits.JBSplits_ZeroSplitPercent.selector);
+        _splits.setSplitGroupsOf(_projectId, _rulesetId, _splitsGroup);
+    }
+
+    function test_GivenSplitsTotalToGtSPLITS_TOTAL_PERCENT() external whenCallerIsController {
+        // it will revert with INVALID_TOTAL_PERCENT
+
+        // data for call with total percent > 100
+        JBSplitGroup[] memory _splitsGroup = new JBSplitGroup[](1);
+        JBSplit[] memory _splitsArray = new JBSplit[](2);
+
+        // Set up a payout split recipient.
+        _splitsArray[0] = JBSplit({
+            preferAddToBalance: false,
+            percent: JBConstants.SPLITS_TOTAL_PERCENT / 2,
+            projectId: _projectId,
+            beneficiary: _bene,
+            lockedUntil: 0,
+            hook: IJBSplitHook(address(0))
+        });
+
+        // Set up a second payout split recipient.
+        _splitsArray[1] = JBSplit({
+            preferAddToBalance: false,
+            percent: JBConstants.SPLITS_TOTAL_PERCENT,
+            projectId: _projectId,
+            beneficiary: _bene,
+            lockedUntil: 0,
+            hook: IJBSplitHook(address(0))
+        });
+
+        // outer structure
+        _splitsGroup[0] = JBSplitGroup({groupId: 0, splits: _splitsArray});
+
+        vm.expectRevert(JBSplits.JBSplits_TotalPercentExceeds100.selector);
+        _splits.setSplitGroupsOf(_projectId, _rulesetId, _splitsGroup);
+    }
+
+    function test_HappyPath() external whenCallerIsController {
+        // it will store splits and emit SetSplit for each configured
+
+        // data for call
+        JBSplitGroup[] memory _splitsGroup = new JBSplitGroup[](1);
+        JBSplit[] memory _splitsArray = new JBSplit[](2);
+
+        // Set up a valid payout split recipient.
+        _splitsArray[0] = JBSplit({
+            preferAddToBalance: false,
+            percent: JBConstants.SPLITS_TOTAL_PERCENT / 2,
+            projectId: _projectId,
+            beneficiary: _bene,
+            lockedUntil: 0,
+            hook: IJBSplitHook(address(0))
+        });
+
+        // Set up a second valid payout split recipient.
+        _splitsArray[1] = JBSplit({
+            preferAddToBalance: false,
+            percent: JBConstants.SPLITS_TOTAL_PERCENT / 2,
+            projectId: _projectId,
+            beneficiary: payable(makeAddr("anotherBene")),
+            lockedUntil: 0,
+            hook: IJBSplitHook(address(0))
+        });
+
+        // outer structure
+        _splitsGroup[0] = JBSplitGroup({groupId: 0, splits: _splitsArray});
+
+        // should emit an event for each split
+        vm.expectEmit();
+        emit IJBSplits.SetSplit(_projectId, block.timestamp, 0, _splitsArray[0], address(this));
+
+        vm.expectEmit();
+        emit IJBSplits.SetSplit(_projectId, block.timestamp, 0, _splitsArray[1], address(this));
+
+        _splits.setSplitGroupsOf(_projectId, _rulesetId, _splitsGroup);
+    }
+
+    function test_GivenSettingExistingIdDomainAndGroup() external whenCallerIsController {
+        // it will overwrite
+
+        // data for call
+        JBSplitGroup[] memory _splitsGroup = new JBSplitGroup[](1);
+        JBSplit[] memory _splitsArray = new JBSplit[](1);
+
+        // Set up a payout split recipient.
+        _splitsArray[0] = JBSplit({
+            preferAddToBalance: false,
+            percent: JBConstants.SPLITS_TOTAL_PERCENT / 2,
+            projectId: _projectId,
+            beneficiary: _bene,
+            lockedUntil: 0,
+            hook: IJBSplitHook(address(0))
+        });
+
+        // outer structure
+        _splitsGroup[0] = JBSplitGroup({groupId: 0, splits: _splitsArray});
+
+        vm.expectEmit();
+        emit IJBSplits.SetSplit(_projectId, block.timestamp, 0, _splitsArray[0], address(this));
+
+        _splits.setSplitGroupsOf(_projectId, _rulesetId, _splitsGroup);
+
+        // Second or "reconfig" call
+
+        // Re-Set up a payout split recipient.
+        _splitsArray[0] = JBSplit({
+            // Different attributes
+            preferAddToBalance: true,
+            percent: JBConstants.SPLITS_TOTAL_PERCENT / 3,
+            projectId: _projectId,
+            beneficiary: _bene,
+            lockedUntil: 0,
+            hook: IJBSplitHook(address(0))
+        });
+
+        // outer structure
+        _splitsGroup[0] = JBSplitGroup({groupId: 0, splits: _splitsArray});
+
+        vm.expectEmit();
+        emit IJBSplits.SetSplit(_projectId, block.timestamp, 0, _splitsArray[0], address(this));
+
+        _splits.setSplitGroupsOf(_projectId, block.timestamp, _splitsGroup);
+
+        JBSplit[] memory _current = _splits.splitsOf(_projectId, block.timestamp, 0);
+
+        assertEq(_current[0].preferAddToBalance, true);
+    }
+
+    function test_GivenAddingNewLockedSplitsIncludingPreviouslyLocked() external whenCallerIsController {
+        // it will reconfigure and extend previously locked splits
+
+        // data for call
+        JBSplitGroup[] memory _splitsGroup = new JBSplitGroup[](1);
+        JBSplit[] memory _splitsArray = new JBSplit[](1);
+
+        // Set up a payout split recipient.
+        _splitsArray[0] = JBSplit({
+            preferAddToBalance: false,
+            percent: JBConstants.SPLITS_TOTAL_PERCENT / 2,
+            projectId: _projectId,
+            beneficiary: _bene,
+            lockedUntil: uint48(block.timestamp + 100),
+            hook: IJBSplitHook(address(0))
+        });
+
+        // outer structure
+        _splitsGroup[0] = JBSplitGroup({groupId: 0, splits: _splitsArray});
+
+        vm.expectEmit();
+        emit IJBSplits.SetSplit(_projectId, block.timestamp, 0, _splitsArray[0], address(this));
+
+        _splits.setSplitGroupsOf(_projectId, _rulesetId, _splitsGroup);
+
+        // Second or "reconfig" call
+
+        JBSplit[] memory _splitsArray2 = new JBSplit[](2);
+
+        // Re-Set up a payout split recipient.
+        _splitsArray2[0] = JBSplit({
+            preferAddToBalance: false,
+            percent: JBConstants.SPLITS_TOTAL_PERCENT / 2,
+            projectId: _projectId,
+            beneficiary: _bene,
+            lockedUntil: uint48(block.timestamp + 100),
+            hook: IJBSplitHook(address(0))
+        });
+
+        // Re-Set up a payout split recipient.
+        _splitsArray2[1] = JBSplit({
+            preferAddToBalance: true,
+            percent: JBConstants.SPLITS_TOTAL_PERCENT / 2,
+            projectId: _projectId,
+            beneficiary: _bene,
+            lockedUntil: uint48(block.timestamp + 200),
+            hook: IJBSplitHook(address(0))
+        });
+
+        // outer structure
+        _splitsGroup[0] = JBSplitGroup({groupId: 0, splits: _splitsArray2});
+
+        vm.expectEmit();
+        emit IJBSplits.SetSplit(_projectId, block.timestamp, 0, _splitsArray2[0], address(this));
+
+        _splits.setSplitGroupsOf(_projectId, block.timestamp, _splitsGroup);
+
+        JBSplit[] memory _current = _splits.splitsOf(_projectId, block.timestamp, 0);
+
+        assertEq(_current[0].lockedUntil, block.timestamp + 100);
+        assertEq(_current[1].lockedUntil, block.timestamp + 200);
+    }
+
+    function test_GivenOverwritingExistingLockedSplitWithReorderedGroup() external whenCallerIsController {
+        // it will overwrite
+
+        // data for call
+        JBSplitGroup[] memory _splitsGroup = new JBSplitGroup[](1);
+        JBSplit[] memory _splitsArray = new JBSplit[](1);
+
+        // Set up a payout split recipient.
+        _splitsArray[0] = JBSplit({
+            preferAddToBalance: false,
+            percent: JBConstants.SPLITS_TOTAL_PERCENT / 2,
+            projectId: _projectId,
+            beneficiary: _bene,
+            lockedUntil: uint48(block.timestamp + 100),
+            hook: IJBSplitHook(address(0))
+        });
+
+        // outer structure
+        _splitsGroup[0] = JBSplitGroup({groupId: 0, splits: _splitsArray});
+
+        vm.expectEmit();
+        emit IJBSplits.SetSplit(_projectId, block.timestamp, 0, _splitsArray[0], address(this));
+
+        _splits.setSplitGroupsOf(_projectId, _rulesetId, _splitsGroup);
+
+        // Second or "reconfig" call
+        JBSplitGroup[] memory _secondSplitsGroup = new JBSplitGroup[](1);
+        JBSplit[] memory _secondSplitsArray = new JBSplit[](2);
+
+        // Re-Set up a payout split recipient.
+        _secondSplitsArray[1] = JBSplit({
+            preferAddToBalance: false,
+            percent: JBConstants.SPLITS_TOTAL_PERCENT / 2,
+            projectId: _projectId,
+            beneficiary: _bene,
+            lockedUntil: uint48(block.timestamp + 100),
+            hook: IJBSplitHook(address(0))
+        });
+
+        _secondSplitsArray[0] = JBSplit({
+            preferAddToBalance: false,
+            percent: JBConstants.SPLITS_TOTAL_PERCENT / 2,
+            projectId: _projectId,
+            beneficiary: _bene,
+            lockedUntil: 0,
+            hook: IJBSplitHook(address(0))
+        });
+
+        // outer structure
+        _secondSplitsGroup[0] = JBSplitGroup({groupId: 0, splits: _secondSplitsArray});
+
+        vm.expectEmit();
+        emit IJBSplits.SetSplit(_projectId, block.timestamp, 0, _secondSplitsArray[0], address(this));
+        emit IJBSplits.SetSplit(_projectId, block.timestamp, 0, _secondSplitsArray[1], address(this));
+
+        _splits.setSplitGroupsOf(_projectId, block.timestamp, _secondSplitsGroup);
+
+        JBSplit[] memory _current = _splits.splitsOf(_projectId, block.timestamp, 0);
+
+        assertEq(_current[0].preferAddToBalance, false);
+    }
+}

package/test/units/static/JBSplits/TestSplitsLockedEdge.sol

@@ -0,0 +1,262 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBSplitsSetup} from "./JBSplitsSetup.sol";
+
+/// @notice Edge case tests for JBSplits lock enforcement.
+/// Key finding: locks only enforce within the SAME rulesetId. A project owner
+/// can bypass a locked split by setting splits under a different rulesetId.
+contract TestSplitsLockedEdge_Local is JBSplitsSetup {
+    uint256 constant PROJECT_ID = 1;
+    uint256 constant RULESET_ID_A = 100;
+    uint256 constant RULESET_ID_B = 200;
+    uint256 constant GROUP_ID = 1;
+    address constant BENEFICIARY = address(0xBEEF);
+
+    IJBSplits public splits;
+
+    function setUp() public {
+        super.splitsSetup();
+        splits = IJBSplits(address(_splits));
+
+        // Mock controllerOf to return this contract.
+        vm.mockCall(
+            address(directory), abi.encodeCall(IJBDirectory.controllerOf, (PROJECT_ID)), abi.encode(address(this))
+        );
+    }
+
+    // Helper to create a split with specified parameters.
+    function _makeSplit(
+        uint32 percent,
+        address beneficiary_,
+        uint48 lockedUntil
+    )
+        internal
+        pure
+        returns (JBSplit memory)
+    {
+        return JBSplit({
+            percent: percent,
+            projectId: 0,
+            beneficiary: payable(beneficiary_),
+            preferAddToBalance: false,
+            lockedUntil: lockedUntil,
+            hook: IJBSplitHook(address(0))
+        });
+    }
+
+    // ───────────────────── Lock enforcement within same ruleset
+    // ─────────────────────
+
+    /// @notice Removing a locked split within the same rulesetId should revert.
+    function test_lockEnforcement_withinSameRuleset() external {
+        // Set a locked split.
+        JBSplit[] memory initialSplits = new JBSplit[](1);
+        initialSplits[0] = _makeSplit(500_000_000, BENEFICIARY, uint48(block.timestamp + 365 days));
+
+        JBSplitGroup[] memory groups = new JBSplitGroup[](1);
+        groups[0] = JBSplitGroup({groupId: GROUP_ID, splits: initialSplits});
+
+        splits.setSplitGroupsOf(PROJECT_ID, RULESET_ID_A, groups);
+
+        // Try to remove the locked split.
+        JBSplit[] memory newSplits = new JBSplit[](1);
+        newSplits[0] = _makeSplit(500_000_000, address(0xDEAD), 0); // Different beneficiary.
+
+        JBSplitGroup[] memory newGroups = new JBSplitGroup[](1);
+        newGroups[0] = JBSplitGroup({groupId: GROUP_ID, splits: newSplits});
+
+        vm.expectRevert(
+            abi.encodeWithSelector(JBSplits.JBSplits_PreviousLockedSplitsNotIncluded.selector, PROJECT_ID, RULESET_ID_A)
+        );
+        splits.setSplitGroupsOf(PROJECT_ID, RULESET_ID_A, newGroups);
+    }
+
+    // ───────────────────── Lock DOES NOT carry across rulesets
+    // ─────────────────────
+
+    /// @notice DESIGN ISSUE: Locked splits in rulesetId A don't constrain rulesetId B.
+    /// A project owner can bypass a lock by queuing a new ruleset without the split.
+    function test_lockEnforcement_acrossRulesets() external {
+        // Set a locked split in rulesetId A.
+        JBSplit[] memory initialSplits = new JBSplit[](1);
+        initialSplits[0] = _makeSplit(500_000_000, BENEFICIARY, uint48(block.timestamp + 365 days));
+
+        JBSplitGroup[] memory groups = new JBSplitGroup[](1);
+        groups[0] = JBSplitGroup({groupId: GROUP_ID, splits: initialSplits});
+
+        splits.setSplitGroupsOf(PROJECT_ID, RULESET_ID_A, groups);
+
+        // Set completely different splits in rulesetId B — this SUCCEEDS even though
+        // the locked split from rulesetId A is not included.
+        JBSplit[] memory newSplits = new JBSplit[](1);
+        newSplits[0] = _makeSplit(500_000_000, address(0xDEAD), 0); // No lock, different beneficiary.
+
+        JBSplitGroup[] memory newGroups = new JBSplitGroup[](1);
+        newGroups[0] = JBSplitGroup({groupId: GROUP_ID, splits: newSplits});
+
+        // This should succeed — locks don't carry across rulesets.
+        splits.setSplitGroupsOf(PROJECT_ID, RULESET_ID_B, newGroups);
+
+        // Verify the new ruleset has different splits.
+        JBSplit[] memory rulesetsB = splits.splitsOf(PROJECT_ID, RULESET_ID_B, GROUP_ID);
+        assertEq(rulesetsB.length, 1, "Ruleset B should have splits");
+        assertEq(rulesetsB[0].beneficiary, address(0xDEAD), "Locked split bypassed via new rulesetId");
+    }
+
+    // ───────────────────── Lock extension allowed
+    // ─────────────────────
+
+    /// @notice Extending lockedUntil to a later time should succeed.
+    function test_lockExtension_allowed() external {
+        uint48 originalLock = uint48(block.timestamp + 180 days);
+        uint48 extendedLock = uint48(block.timestamp + 365 days);
+
+        JBSplit[] memory initialSplits = new JBSplit[](1);
+        initialSplits[0] = _makeSplit(500_000_000, BENEFICIARY, originalLock);
+
+        JBSplitGroup[] memory groups = new JBSplitGroup[](1);
+        groups[0] = JBSplitGroup({groupId: GROUP_ID, splits: initialSplits});
+        splits.setSplitGroupsOf(PROJECT_ID, RULESET_ID_A, groups);
+
+        // Extend the lock.
+        JBSplit[] memory extendedSplits = new JBSplit[](1);
+        extendedSplits[0] = _makeSplit(500_000_000, BENEFICIARY, extendedLock);
+
+        JBSplitGroup[] memory extendedGroups = new JBSplitGroup[](1);
+        extendedGroups[0] = JBSplitGroup({groupId: GROUP_ID, splits: extendedSplits});
+
+        // Should succeed — lock extension is allowed.
+        splits.setSplitGroupsOf(PROJECT_ID, RULESET_ID_A, extendedGroups);
+
+        JBSplit[] memory result = splits.splitsOf(PROJECT_ID, RULESET_ID_A, GROUP_ID);
+        assertEq(result[0].lockedUntil, extendedLock, "Lock should be extended");
+    }
+
+    // ───────────────────── Lock reduction blocked
+    // ─────────────────────
+
+    /// @notice Reducing lockedUntil (while still locked) should revert.
+    function test_lockReduction_blocked() external {
+        uint48 originalLock = uint48(block.timestamp + 365 days);
+        uint48 reducedLock = uint48(block.timestamp + 90 days);
+
+        JBSplit[] memory initialSplits = new JBSplit[](1);
+        initialSplits[0] = _makeSplit(500_000_000, BENEFICIARY, originalLock);
+
+        JBSplitGroup[] memory groups = new JBSplitGroup[](1);
+        groups[0] = JBSplitGroup({groupId: GROUP_ID, splits: initialSplits});
+        splits.setSplitGroupsOf(PROJECT_ID, RULESET_ID_A, groups);
+
+        // Try to reduce the lock — should fail.
+        JBSplit[] memory reducedSplits = new JBSplit[](1);
+        reducedSplits[0] = _makeSplit(500_000_000, BENEFICIARY, reducedLock);
+
+        JBSplitGroup[] memory reducedGroups = new JBSplitGroup[](1);
+        reducedGroups[0] = JBSplitGroup({groupId: GROUP_ID, splits: reducedSplits});
+
+        vm.expectRevert(
+            abi.encodeWithSelector(JBSplits.JBSplits_PreviousLockedSplitsNotIncluded.selector, PROJECT_ID, RULESET_ID_A)
+        );
+        splits.setSplitGroupsOf(PROJECT_ID, RULESET_ID_A, reducedGroups);
+    }
+
+    // ───────────────────── Lock expired allows removal
+    // ─────────────────────
+
+    /// @notice After lockedUntil passes, split can be removed.
+    function test_lockExpired_canRemove() external {
+        uint48 lockTime = uint48(block.timestamp + 30 days);
+
+        JBSplit[] memory initialSplits = new JBSplit[](1);
+        initialSplits[0] = _makeSplit(500_000_000, BENEFICIARY, lockTime);
+
+        JBSplitGroup[] memory groups = new JBSplitGroup[](1);
+        groups[0] = JBSplitGroup({groupId: GROUP_ID, splits: initialSplits});
+        splits.setSplitGroupsOf(PROJECT_ID, RULESET_ID_A, groups);
+
+        // Warp past lock expiry.
+        vm.warp(lockTime + 1);
+
+        // Now remove the split — should succeed.
+        JBSplit[] memory newSplits = new JBSplit[](1);
+        newSplits[0] = _makeSplit(500_000_000, address(0xDEAD), 0);
+
+        JBSplitGroup[] memory newGroups = new JBSplitGroup[](1);
+        newGroups[0] = JBSplitGroup({groupId: GROUP_ID, splits: newSplits});
+
+        splits.setSplitGroupsOf(PROJECT_ID, RULESET_ID_A, newGroups);
+
+        JBSplit[] memory result = splits.splitsOf(PROJECT_ID, RULESET_ID_A, GROUP_ID);
+        assertEq(result[0].beneficiary, address(0xDEAD), "Expired lock allows removal");
+    }
+
+    // ───────────────────── Percent validation
+    // ─────────────────────
+
+    /// @notice Total percent > SPLITS_TOTAL_PERCENT should revert.
+    function test_percentExceeds100_reverts() external {
+        JBSplit[] memory splitArray = new JBSplit[](2);
+        splitArray[0] = _makeSplit(600_000_000, BENEFICIARY, 0); // 60%
+        splitArray[1] = _makeSplit(500_000_000, address(0xDEAD), 0); // 50% → total 110%
+
+        JBSplitGroup[] memory groups = new JBSplitGroup[](1);
+        groups[0] = JBSplitGroup({groupId: GROUP_ID, splits: splitArray});
+
+        vm.expectRevert(JBSplits.JBSplits_TotalPercentExceeds100.selector);
+        splits.setSplitGroupsOf(PROJECT_ID, RULESET_ID_A, groups);
+    }
+
+    /// @notice Any split with percent=0 should revert.
+    function test_zeroPercent_reverts() external {
+        JBSplit[] memory splitArray = new JBSplit[](1);
+        splitArray[0] = _makeSplit(0, BENEFICIARY, 0);
+
+        JBSplitGroup[] memory groups = new JBSplitGroup[](1);
+        groups[0] = JBSplitGroup({groupId: GROUP_ID, splits: splitArray});
+
+        vm.expectRevert(JBSplits.JBSplits_ZeroSplitPercent.selector);
+        splits.setSplitGroupsOf(PROJECT_ID, RULESET_ID_A, groups);
+    }
+
+    // ───────────────────── Hook and beneficiary edge cases
+    // ─────────────────────
+
+    /// @notice Arbitrary address as hook is accepted (no interface check).
+    function test_hookAddress_notValidated() external {
+        JBSplit[] memory splitArray = new JBSplit[](1);
+        splitArray[0] = JBSplit({
+            percent: 500_000_000,
+            projectId: 0,
+            beneficiary: payable(BENEFICIARY),
+            preferAddToBalance: false,
+            lockedUntil: 0,
+            hook: IJBSplitHook(address(0x1234)) // Arbitrary address — no interface validation.
+        });
+
+        JBSplitGroup[] memory groups = new JBSplitGroup[](1);
+        groups[0] = JBSplitGroup({groupId: GROUP_ID, splits: splitArray});
+
+        // Should succeed — no ERC165 or interface check.
+        splits.setSplitGroupsOf(PROJECT_ID, RULESET_ID_A, groups);
+
+        JBSplit[] memory result = splits.splitsOf(PROJECT_ID, RULESET_ID_A, GROUP_ID);
+        assertEq(address(result[0].hook), address(0x1234), "Arbitrary hook address accepted");
+    }
+
+    /// @notice address(0) beneficiary is valid (potential footgun).
+    function test_beneficiaryZero_accepted() external {
+        JBSplit[] memory splitArray = new JBSplit[](1);
+        splitArray[0] = _makeSplit(500_000_000, address(0), 0);
+
+        JBSplitGroup[] memory groups = new JBSplitGroup[](1);
+        groups[0] = JBSplitGroup({groupId: GROUP_ID, splits: splitArray});
+
+        // Should succeed — no zero-address check.
+        splits.setSplitGroupsOf(PROJECT_ID, RULESET_ID_A, groups);
+
+        JBSplit[] memory result = splits.splitsOf(PROJECT_ID, RULESET_ID_A, GROUP_ID);
+        assertEq(result[0].beneficiary, address(0), "Zero beneficiary accepted (footgun)");
+    }
+}

package/test/units/static/JBSplits/TestSplitsOf.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBSplitsSetup} from "./JBSplitsSetup.sol";
+
+contract TestSplitsOf_Local is JBSplitsSetup {
+    function setUp() public {
+        super.splitsSetup();
+    }
+
+    // This is covered under TestSetSplitGroupsOf
+    /* function test_WhenThereAreDefinedSplits() external {
+        // it should return the defined splits
+    } */
+
+    function test_WhenThereAreNoSplitsDefined() external view {
+        // it should return the default splits for FALLBACK_RULESET_ID
+
+        JBSplit[] memory _current = _splits.splitsOf(1, block.timestamp, 0);
+
+        assertEq(_current.length, 0);
+    }
+}

package/test/units/static/JBSplits/TestSplitsPacking.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import "src/JBSplits.sol";
+import "forge-std/Test.sol";
+
+contract TestSplitsPacking_Local is JBSplits, Test {
+    constructor() JBSplits(IJBDirectory(address(0))) {}
+
+    function test_SplitsPacking(JBSplit calldata _split) external {
+        // Ensure the split percentage is within bounds.
+        vm.assume(_split.percent != 0 && _split.percent <= JBConstants.SPLITS_TOTAL_PERCENT);
+
+        JBSplit[] memory _splits = new JBSplit[](1);
+        _splits[0] = _split;
+
+        _setSplitsOf(1, 1, 1, _splits);
+        JBSplit memory _unpackedSplit = _getStructsFor(1, 1, 1)[0];
+
+        assertEq(_split.percent, _unpackedSplit.percent, "Percent packing is lossy");
+        assertEq(_split.projectId, _unpackedSplit.projectId, "Project ID packing is lossy");
+        assertEq(_split.beneficiary, _unpackedSplit.beneficiary, "Beneficiary packing is lossy");
+        assertEq(_split.preferAddToBalance, _unpackedSplit.preferAddToBalance, "preferAddToBalance packing is lossy");
+        assertEq(_split.lockedUntil, _unpackedSplit.lockedUntil, "lockedUntil packing is lossy");
+        assertEq(address(_split.hook), address(_unpackedSplit.hook), "hook packing is lossy");
+
+        assertEq(
+            keccak256(abi.encode(_split)),
+            keccak256(abi.encode(_unpackedSplit)),
+            "Packing and unpacking of a split is lossy"
+        );
+    }
+}