@bananapus/core-v6 0.0.31 → 0.0.33

package/src/JBRulesets.sol

@@ -208,8 +208,8 @@ contract JBRulesets is JBControlled, IJBRulesets {
             caller: msg.sender
         });
 
-        // Return the struct for the new ruleset's ID.
-        return _getStructFor({projectId: projectId, rulesetId: rulesetId});
+        // Return the struct for the new ruleset's ID, with metadata.
+        return _getStructFor({projectId: projectId, rulesetId: rulesetId, withMetadata: true});
     }
 
     /// @notice Cache the value of the ruleset weight for a specific ruleset.
@@ -221,7 +221,8 @@ contract JBRulesets is JBControlled, IJBRulesets {
     /// @param rulesetId The ID of the ruleset to update the cache for.
     function updateRulesetWeightCache(uint256 projectId, uint256 rulesetId) external override {
         // Get the target ruleset.
-        JBRuleset memory targetRuleset = _getStructFor({projectId: projectId, rulesetId: rulesetId});
+        JBRuleset memory targetRuleset =
+            _getStructFor({projectId: projectId, rulesetId: rulesetId, withMetadata: false});
 
         // Nothing to cache if the target ruleset doesn't have a duration or a weight cut percent.
         // slither-disable-next-line incorrect-equality
@@ -296,8 +297,8 @@ contract JBRulesets is JBControlled, IJBRulesets {
         // Keep a reference to the number of rulesets being returned.
         uint256 count = 0;
 
-        // Keep a reference to the starting ruleset.
-        JBRuleset memory ruleset = _getStructFor({projectId: projectId, rulesetId: startingId});
+        // Keep a reference to the starting ruleset (metadata not needed — only counting).
+        JBRuleset memory ruleset = _getStructFor({projectId: projectId, rulesetId: startingId, withMetadata: false});
 
         // First, count the number of rulesets to include in the result by iterating backwards from the starting
         // ruleset.
@@ -306,7 +307,7 @@ contract JBRulesets is JBControlled, IJBRulesets {
             count++;
 
             // Iterate to the ruleset it was based on.
-            ruleset = _getStructFor({projectId: projectId, rulesetId: ruleset.basedOnId});
+            ruleset = _getStructFor({projectId: projectId, rulesetId: ruleset.basedOnId, withMetadata: false});
         }
 
         // Keep a reference to the array of rulesets that'll be populated.
@@ -317,8 +318,8 @@ contract JBRulesets is JBControlled, IJBRulesets {
             return rulesets;
         }
 
-        // Reset the ruleset being iterated on to the starting ruleset.
-        ruleset = _getStructFor({projectId: projectId, rulesetId: startingId});
+        // Reset the ruleset being iterated on to the starting ruleset, now with metadata for the return array.
+        ruleset = _getStructFor({projectId: projectId, rulesetId: startingId, withMetadata: true});
 
         // Set the counter.
         uint256 i;
@@ -328,8 +329,10 @@ contract JBRulesets is JBControlled, IJBRulesets {
             // Add the ruleset to the array.
             rulesets[i++] = ruleset;
 
-            // Get the ruleset it was based on if needed.
-            if (i != count) ruleset = _getStructFor({projectId: projectId, rulesetId: ruleset.basedOnId});
+            // Get the ruleset it was based on if needed, with metadata for the return array.
+            if (i != count) {
+                ruleset = _getStructFor({projectId: projectId, rulesetId: ruleset.basedOnId, withMetadata: true});
+            }
         }
     }
 
@@ -345,8 +348,8 @@ contract JBRulesets is JBControlled, IJBRulesets {
         // Get a reference to the latest ruleset ID.
         uint256 rulesetId = latestRulesetIdOf[projectId];
 
-        // Resolve the struct for the latest ruleset.
-        JBRuleset memory ruleset = _getStructFor({projectId: projectId, rulesetId: rulesetId});
+        // Resolve the struct for the latest ruleset, with metadata (forwarded to the external approval hook).
+        JBRuleset memory ruleset = _getStructFor({projectId: projectId, rulesetId: rulesetId, withMetadata: true});
 
         return _approvalStatusOf({projectId: projectId, ruleset: ruleset});
     }
@@ -362,15 +365,18 @@ contract JBRulesets is JBControlled, IJBRulesets {
     function currentOf(uint256 projectId) external view override returns (JBRuleset memory ruleset) {
         // If the project does not have a ruleset, return an empty struct.
         // slither-disable-next-line incorrect-equality
-        if (latestRulesetIdOf[projectId] == 0) return _getStructFor({projectId: 0, rulesetId: 0});
+        if (latestRulesetIdOf[projectId] == 0) {
+            return _getStructFor({projectId: 0, rulesetId: 0, withMetadata: false});
+        }
 
         // Get a reference to the currently approvable ruleset's ID.
         uint256 rulesetId = _currentlyApprovableRulesetIdOf(projectId);
 
         // If a currently approvable ruleset exists...
         if (rulesetId != 0) {
-            // Resolve the struct for the currently approvable ruleset.
-            ruleset = _getStructFor({projectId: projectId, rulesetId: rulesetId});
+            // Resolve the struct for the currently approvable ruleset, with metadata (forwarded to external hooks
+            // and potentially returned).
+            ruleset = _getStructFor({projectId: projectId, rulesetId: rulesetId, withMetadata: true});
 
             // Get a reference to the approval status.
             JBApprovalStatus approvalStatus = _approvalStatusOf({projectId: projectId, ruleset: ruleset});
@@ -387,15 +393,16 @@ contract JBRulesets is JBControlled, IJBRulesets {
             // which carries the last approved configuration.
             rulesetId = ruleset.basedOnId;
 
-            // Keep a reference to its ruleset.
-            ruleset = _getStructFor({projectId: projectId, rulesetId: rulesetId});
+            // Keep a reference to its ruleset, with metadata (used by `_simulateCycledRulesetBasedOn` and may be
+            // returned).
+            ruleset = _getStructFor({projectId: projectId, rulesetId: rulesetId, withMetadata: true});
         } else {
             // No upcoming ruleset found that is currently approvable,
             // so use the latest ruleset ID.
             rulesetId = latestRulesetIdOf[projectId];
 
-            // Get the struct for the latest ID.
-            ruleset = _getStructFor({projectId: projectId, rulesetId: rulesetId});
+            // Get the struct for the latest ID, with metadata (forwarded to external hooks and may be returned).
+            ruleset = _getStructFor({projectId: projectId, rulesetId: rulesetId, withMetadata: true});
 
             // Get a reference to the approval status.
             JBApprovalStatus approvalStatus = _approvalStatusOf({projectId: projectId, ruleset: ruleset});
@@ -407,7 +414,7 @@ contract JBRulesets is JBControlled, IJBRulesets {
                     || block.timestamp < ruleset.start
             ) {
                 rulesetId = ruleset.basedOnId;
-                ruleset = _getStructFor({projectId: projectId, rulesetId: rulesetId});
+                ruleset = _getStructFor({projectId: projectId, rulesetId: rulesetId, withMetadata: true});
                 approvalStatus = _approvalStatusOf({projectId: projectId, ruleset: ruleset});
             }
         }
@@ -433,7 +440,7 @@ contract JBRulesets is JBControlled, IJBRulesets {
         override
         returns (JBRuleset memory ruleset)
     {
-        return _getStructFor({projectId: projectId, rulesetId: rulesetId});
+        ruleset = _getStructFor({projectId: projectId, rulesetId: rulesetId, withMetadata: true});
     }
 
     /// @notice The latest ruleset queued for a project. Returns the ruleset's struct and its current approval status.
@@ -451,8 +458,9 @@ contract JBRulesets is JBControlled, IJBRulesets {
         // Get a reference to the latest ruleset's ID.
         uint256 rulesetId = latestRulesetIdOf[projectId];
 
-        // Resolve the struct for the latest ruleset.
-        ruleset = _getStructFor({projectId: projectId, rulesetId: rulesetId});
+        // Resolve the struct for the latest ruleset, with metadata (forwarded to the external approval hook and
+        // returned).
+        ruleset = _getStructFor({projectId: projectId, rulesetId: rulesetId, withMetadata: true});
 
         // Resolve the approval status.
         approvalStatus = _approvalStatusOf({projectId: projectId, ruleset: ruleset});
@@ -465,7 +473,9 @@ contract JBRulesets is JBControlled, IJBRulesets {
     function upcomingOf(uint256 projectId) external view override returns (JBRuleset memory ruleset) {
         // If the project does not have a latest ruleset, return an empty struct.
         // slither-disable-next-line incorrect-equality
-        if (latestRulesetIdOf[projectId] == 0) return _getStructFor({projectId: 0, rulesetId: 0});
+        if (latestRulesetIdOf[projectId] == 0) {
+            return _getStructFor({projectId: 0, rulesetId: 0, withMetadata: false});
+        }
 
         // Get a reference to the upcoming approvable ruleset's ID.
         uint256 upcomingApprovableRulesetId = _upcomingApprovableRulesetIdOf(projectId);
@@ -476,7 +486,7 @@ contract JBRulesets is JBControlled, IJBRulesets {
         // If an upcoming approvable ruleset has been queued, and it's approval status is Approved or ApprovalExpected,
         // return its ruleset struct
         if (upcomingApprovableRulesetId != 0) {
-            ruleset = _getStructFor({projectId: projectId, rulesetId: upcomingApprovableRulesetId});
+            ruleset = _getStructFor({projectId: projectId, rulesetId: upcomingApprovableRulesetId, withMetadata: true});
 
             // Get a reference to the approval status.
             approvalStatus = _approvalStatusOf({projectId: projectId, ruleset: ruleset});
@@ -488,23 +498,25 @@ contract JBRulesets is JBControlled, IJBRulesets {
                     || approvalStatus == JBApprovalStatus.Empty
             ) return ruleset;
 
-            // Resolve the ruleset for the ruleset the upcoming approvable ruleset was based on.
-            ruleset = _getStructFor({projectId: projectId, rulesetId: ruleset.basedOnId});
+            // Resolve the ruleset for the ruleset the upcoming approvable ruleset was based on, with metadata
+            // (used by `_simulateCycledRulesetBasedOn`).
+            ruleset = _getStructFor({projectId: projectId, rulesetId: ruleset.basedOnId, withMetadata: true});
         } else {
-            // Resolve the ruleset for the latest queued ruleset.
-            ruleset = _getStructFor({projectId: projectId, rulesetId: latestRulesetIdOf[projectId]});
+            // Resolve the ruleset for the latest queued ruleset, with metadata (forwarded to external hooks and used
+            // by `_simulateCycledRulesetBasedOn`).
+            ruleset = _getStructFor({projectId: projectId, rulesetId: latestRulesetIdOf[projectId], withMetadata: true});
 
             // If the latest ruleset starts in the future, it must start in the distant future
             // Since its not the upcoming approvable ruleset. In this case, base the upcoming ruleset on the base
             // ruleset.
             while (ruleset.start > block.timestamp) {
-                ruleset = _getStructFor({projectId: projectId, rulesetId: ruleset.basedOnId});
+                ruleset = _getStructFor({projectId: projectId, rulesetId: ruleset.basedOnId, withMetadata: true});
             }
         }
 
         // There's no queued if the current has a duration of 0.
         // slither-disable-next-line incorrect-equality
-        if (ruleset.duration == 0) return _getStructFor({projectId: 0, rulesetId: 0});
+        if (ruleset.duration == 0) return _getStructFor({projectId: 0, rulesetId: 0, withMetadata: false});
 
         // Get a reference to the approval status.
         approvalStatus = _approvalStatusOf({projectId: projectId, ruleset: ruleset});
@@ -516,12 +528,13 @@ contract JBRulesets is JBControlled, IJBRulesets {
             return _simulateCycledRulesetBasedOn({projectId: projectId, baseRuleset: ruleset, allowMidRuleset: false});
         }
 
-        // Get the ruleset of its base ruleset, which carries the last approved configuration.
-        ruleset = _getStructFor({projectId: projectId, rulesetId: ruleset.basedOnId});
+        // Get the ruleset of its base ruleset, which carries the last approved configuration. Metadata is needed by
+        // `_simulateCycledRulesetBasedOn`.
+        ruleset = _getStructFor({projectId: projectId, rulesetId: ruleset.basedOnId, withMetadata: true});
 
         // There's no queued if the base, which must still be the current, has a duration of 0.
         // slither-disable-next-line incorrect-equality
-        if (ruleset.duration == 0) return _getStructFor({projectId: 0, rulesetId: 0});
+        if (ruleset.duration == 0) return _getStructFor({projectId: 0, rulesetId: 0, withMetadata: false});
 
         // Return a simulated cycled ruleset.
         return _simulateCycledRulesetBasedOn({projectId: projectId, baseRuleset: ruleset, allowMidRuleset: false});
@@ -672,17 +685,19 @@ contract JBRulesets is JBControlled, IJBRulesets {
             revert JBRulesets_WeightCacheRequired(projectId);
         }
 
-        for (uint256 i; i < weightCutMultiple; i++) {
-            // The number of times to apply the weight cut percent.
+        // Cache the cut factor and max percent to avoid recomputing each iteration.
+        uint256 cutFactor = JBConstants.MAX_WEIGHT_CUT_PERCENT - baseRulesetWeightCutPercent;
+        uint256 maxPercent = JBConstants.MAX_WEIGHT_CUT_PERCENT;
+
+        for (uint256 i; i < weightCutMultiple;) {
             // Base the new weight on the specified ruleset's weight.
-            weight = mulDiv(
-                weight,
-                JBConstants.MAX_WEIGHT_CUT_PERCENT - baseRulesetWeightCutPercent,
-                JBConstants.MAX_WEIGHT_CUT_PERCENT
-            );
+            weight = mulDiv(weight, cutFactor, maxPercent);
 
             // The calculation doesn't need to continue if the weight is 0.
             if (weight == 0) break;
+            unchecked {
+                ++i;
+            }
         }
     }
 
@@ -713,15 +728,16 @@ contract JBRulesets is JBControlled, IJBRulesets {
             // Use an empty ruleset as the base.
             return _initializeRulesetFor({
                 projectId: projectId,
-                baseRuleset: _getStructFor({projectId: 0, rulesetId: 0}),
+                baseRuleset: _getStructFor({projectId: 0, rulesetId: 0, withMetadata: false}),
                 rulesetId: rulesetId,
                 mustStartAtOrAfter: mustStartAtOrAfter,
                 weight: weight
             });
         }
 
-        // Get a reference to the latest ruleset's struct.
-        JBRuleset memory baseRuleset = _getStructFor({projectId: projectId, rulesetId: latestId});
+        // Get a reference to the latest ruleset's struct, with metadata because `_approvalStatusOf` forwards the
+        // struct to external approval hooks.
+        JBRuleset memory baseRuleset = _getStructFor({projectId: projectId, rulesetId: latestId, withMetadata: true});
 
         // Get a reference to the approval status.
         JBApprovalStatus approvalStatus = _approvalStatusOf({projectId: projectId, ruleset: baseRuleset});
@@ -743,7 +759,9 @@ contract JBRulesets is JBControlled, IJBRulesets {
                     && approvalStatus != JBApprovalStatus.ApprovalExpected
                     && approvalStatus != JBApprovalStatus.Empty)
         ) {
-            baseRuleset = _getStructFor({projectId: projectId, rulesetId: baseRuleset.basedOnId});
+            // Metadata not needed — the fallback ruleset is only used for intrinsic fields (start, basedOnId, etc.)
+            // and not forwarded to any external approval hook.
+            baseRuleset = _getStructFor({projectId: projectId, rulesetId: baseRuleset.basedOnId, withMetadata: false});
         }
 
         // Make sure the ruleset starts after the base ruleset.
@@ -896,11 +914,14 @@ contract JBRulesets is JBControlled, IJBRulesets {
         // slither-disable-next-line incorrect-equality
         if (ruleset.basedOnId == 0) return JBApprovalStatus.Empty;
 
-        // Get the struct of the ruleset with the approval hook.
-        JBRuleset memory approvalHookRuleset = _getStructFor({projectId: projectId, rulesetId: ruleset.basedOnId});
+        // Read only the packed user properties to extract the approval hook address,
+        // avoiding the cost of loading the full parent ruleset struct.
+        uint256 packedUserProperties = _packedUserPropertiesOf[projectId][ruleset.basedOnId];
+        // forge-lint: disable-next-line(unsafe-typecast)
+        IJBRulesetApprovalHook approvalHook = IJBRulesetApprovalHook(address(uint160(packedUserProperties)));
 
         // If there is no approval hook, it's considered empty.
-        if (approvalHookRuleset.approvalHook == IJBRulesetApprovalHook(address(0))) {
+        if (approvalHook == IJBRulesetApprovalHook(address(0))) {
             return JBApprovalStatus.Empty;
         }
 
@@ -909,9 +930,7 @@ contract JBRulesets is JBControlled, IJBRulesets {
         // Note: A malicious hook that consumes all gas (e.g. infinite loop) could still DoS via gas exhaustion.
         // This is accepted risk since the project owner chose their own approval hook.
         // slither-disable-next-line calls-loop
-        try approvalHookRuleset.approvalHook.approvalStatusOf({projectId: projectId, ruleset: ruleset}) returns (
-            JBApprovalStatus status
-        ) {
+        try approvalHook.approvalStatusOf({projectId: projectId, ruleset: ruleset}) returns (JBApprovalStatus status) {
             return status;
         } catch {
             return JBApprovalStatus.Failed;
@@ -928,8 +947,8 @@ contract JBRulesets is JBControlled, IJBRulesets {
         // Get a reference to the project's latest ruleset.
         uint256 rulesetId = latestRulesetIdOf[projectId];
 
-        // Get the struct for the latest ruleset.
-        JBRuleset memory ruleset = _getStructFor({projectId: projectId, rulesetId: rulesetId});
+        // Get the struct for the latest ruleset (metadata not needed — only traversal fields are checked).
+        JBRuleset memory ruleset = _getStructFor({projectId: projectId, rulesetId: rulesetId, withMetadata: false});
 
         // Loop through all most recently queued rulesets until an approvable one is found, or we've proven one can't
         // exist.
@@ -945,17 +964,28 @@ contract JBRulesets is JBControlled, IJBRulesets {
                 return ruleset.id;
             }
 
-            ruleset = _getStructFor({projectId: projectId, rulesetId: ruleset.basedOnId});
+            ruleset = _getStructFor({projectId: projectId, rulesetId: ruleset.basedOnId, withMetadata: false});
         } while (ruleset.cycleNumber != 0);
 
         return 0;
     }
 
-    /// @notice Unpack a ruleset's packed stored values into an easy-to-work-with ruleset struct.
+    /// @notice Unpack a ruleset's packed stored values into a struct.
+    /// @dev When `withMetadata` is false, one cold SLOAD (~2,100 gas) is skipped — use this for linked-list traversal
+    /// where only id, start, duration, basedOnId, etc. are needed.
     /// @param projectId The ID of the project the ruleset belongs to.
-    /// @param rulesetId The ID of the ruleset to get the full struct for.
-    /// @return ruleset A ruleset struct.
-    function _getStructFor(uint256 projectId, uint256 rulesetId) internal view returns (JBRuleset memory ruleset) {
+    /// @param rulesetId The ID of the ruleset to get the struct for.
+    /// @param withMetadata Whether to load the packed metadata from storage.
+    /// @return ruleset The ruleset struct (`metadata` is 0 when `withMetadata` is false).
+    function _getStructFor(
+        uint256 projectId,
+        uint256 rulesetId,
+        bool withMetadata
+    )
+        internal
+        view
+        returns (JBRuleset memory ruleset)
+    {
         // Return an empty ruleset if the specified `rulesetId` is 0.
         // slither-disable-next-line incorrect-equality
         if (rulesetId == 0) return ruleset;
@@ -990,7 +1020,8 @@ contract JBRulesets is JBControlled, IJBRulesets {
         // forge-lint: disable-next-line(unsafe-typecast)
         ruleset.weightCutPercent = uint32(packedUserProperties >> 192);
 
-        ruleset.metadata = _metadataOf[projectId][rulesetId];
+        // Load metadata only when needed — saves one cold SLOAD (~2,100 gas) for traversal-only paths.
+        if (withMetadata) ruleset.metadata = _metadataOf[projectId][rulesetId];
     }
 
     /// @notice A simulated view of the ruleset that would be created if the provided one cycled over (if the project
@@ -1067,8 +1098,8 @@ contract JBRulesets is JBControlled, IJBRulesets {
         // Get a reference to the ID of the project's latest ruleset.
         rulesetId = latestRulesetIdOf[projectId];
 
-        // Get the struct for the latest ruleset.
-        JBRuleset memory ruleset = _getStructFor({projectId: projectId, rulesetId: rulesetId});
+        // Get the struct for the latest ruleset (metadata not needed — only traversal fields are checked).
+        JBRuleset memory ruleset = _getStructFor({projectId: projectId, rulesetId: rulesetId, withMetadata: false});
 
         // There is no upcoming ruleset if the latest ruleset has already started.
         // slither-disable-next-line incorrect-equality
@@ -1086,7 +1117,7 @@ contract JBRulesets is JBControlled, IJBRulesets {
 
         // Find the base ruleset that is not still queued.
         while (true) {
-            baseRuleset = _getStructFor({projectId: projectId, rulesetId: basedOnId});
+            baseRuleset = _getStructFor({projectId: projectId, rulesetId: basedOnId, withMetadata: false});
 
             // If the base ruleset starts in the future,
             if (block.timestamp < baseRuleset.start) {
@@ -1100,8 +1131,8 @@ contract JBRulesets is JBControlled, IJBRulesets {
             }
         }
 
-        // Get the ruleset struct for the ID found.
-        ruleset = _getStructFor({projectId: projectId, rulesetId: rulesetId});
+        // Get the ruleset struct for the ID found (metadata not needed — only `start` and `duration` are checked).
+        ruleset = _getStructFor({projectId: projectId, rulesetId: rulesetId, withMetadata: false});
 
         // If the latest ruleset doesn't start until after another base ruleset return 0.
         if (baseRuleset.duration != 0 && block.timestamp < ruleset.start - baseRuleset.duration) {

package/src/JBSplits.sol

@@ -97,15 +97,13 @@ contract JBSplits is JBControlled, IJBSplits {
         // Cache whether the controller check has already passed to avoid repeated external calls.
         bool controllerChecked;
 
-        // Set each grouped splits.
-        for (uint256 i; i < splitGroups.length; i++) {
-            // Get a reference to the grouped split being iterated on.
-            JBSplitGroup memory splitGroup = splitGroups[i];
-
+        // Set each grouped splits. Access calldata directly to avoid copying each split group to memory.
+        for (uint256 i; i < splitGroups.length;) {
             // Self-auth: lower 160 bits must match msg.sender AND upper 96 bits must be non-zero.
             // GroupIds with zero upper bits are reserved for protocol use (e.g. terminal payout groups)
             // and always require controller authorization to prevent token contracts from hijacking payouts.
-            bool isSelfManaged = splitGroup.groupId >> 160 != 0 && address(uint160(splitGroup.groupId)) == msg.sender;
+            bool isSelfManaged =
+                splitGroups[i].groupId >> 160 != 0 && address(uint160(splitGroups[i].groupId)) == msg.sender;
 
             if (!isSelfManaged && !controllerChecked) {
                 _onlyControllerOf(projectId);
@@ -114,8 +112,14 @@ contract JBSplits is JBControlled, IJBSplits {
 
             // Set the splits for the group.
             _setSplitsOf({
-                projectId: projectId, rulesetId: rulesetId, groupId: splitGroup.groupId, splits: splitGroup.splits
+                projectId: projectId,
+                rulesetId: rulesetId,
+                groupId: splitGroups[i].groupId,
+                splits: splitGroups[i].splits
             });
+            unchecked {
+                ++i;
+            }
         }
     }
 
@@ -168,7 +172,7 @@ contract JBSplits is JBControlled, IJBSplits {
         uint256 numberOfCurrentSplits = currentSplits.length;
 
         // Check to see if all locked splits are included in the array of splits which is being set.
-        for (uint256 i; i < numberOfCurrentSplits; i++) {
+        for (uint256 i; i < numberOfCurrentSplits;) {
             // If not locked, continue.
             if (
                 block.timestamp < currentSplits[i].lockedUntil
@@ -176,6 +180,9 @@ contract JBSplits is JBControlled, IJBSplits {
             ) {
                 revert JBSplits_PreviousLockedSplitsNotIncluded(projectId, rulesetId);
             }
+            unchecked {
+                ++i;
+            }
         }
 
         // Add up all the `percent`s to make sure their total is under 100%.
@@ -184,7 +191,7 @@ contract JBSplits is JBControlled, IJBSplits {
         // Keep a reference to the number of splits to set.
         uint256 numberOfSplits = splits.length;
 
-        for (uint256 i; i < numberOfSplits; i++) {
+        for (uint256 i; i < numberOfSplits;) {
             // Set the split being iterated on.
             JBSplit memory split = splits[i];
 
@@ -228,6 +235,9 @@ contract JBSplits is JBControlled, IJBSplits {
             emit SetSplit({
                 projectId: projectId, rulesetId: rulesetId, groupId: groupId, split: split, caller: msg.sender
             });
+            unchecked {
+                ++i;
+            }
         }
 
         // Store the number of splits for the project, ruleset, and group.
@@ -235,9 +245,12 @@ contract JBSplits is JBControlled, IJBSplits {
 
         // Clean up stale storage slots if the new split count is less than the previous count.
         // This zeroes out leftover packed data to reclaim gas via storage refunds.
-        for (uint256 i = numberOfSplits; i < numberOfCurrentSplits; i++) {
+        for (uint256 i = numberOfSplits; i < numberOfCurrentSplits;) {
             delete _packedSplitParts1Of[projectId][rulesetId][groupId][i];
             delete _packedSplitParts2Of[projectId][rulesetId][groupId][i];
+            unchecked {
+                ++i;
+            }
         }
     }
 
@@ -267,7 +280,7 @@ contract JBSplits is JBControlled, IJBSplits {
         JBSplit[] memory splits = new JBSplit[](splitCount);
 
         // Loop through each split and unpack the values into structs.
-        for (uint256 i; i < splitCount; i++) {
+        for (uint256 i; i < splitCount;) {
             // Get a reference to the first part of the split's packed data.
             uint256 packedSplitPart1 = _packedSplitParts1Of[projectId][rulesetId][groupId][i];
 
@@ -301,6 +314,9 @@ contract JBSplits is JBControlled, IJBSplits {
 
             // Add the split to the value being returned.
             splits[i] = split;
+            unchecked {
+                ++i;
+            }
         }
 
         return splits;
@@ -314,7 +330,7 @@ contract JBSplits is JBControlled, IJBSplits {
         // Keep a reference to the number of splits.
         uint256 numberOfSplits = splits.length;
 
-        for (uint256 i; i < numberOfSplits; i++) {
+        for (uint256 i; i < numberOfSplits;) {
             // Set the split being iterated on.
             JBSplit memory split = splits[i];
 
@@ -326,6 +342,9 @@ contract JBSplits is JBControlled, IJBSplits {
                     && split.preferAddToBalance == lockedSplit.preferAddToBalance
                     && split.lockedUntil >= lockedSplit.lockedUntil
             ) return true;
+            unchecked {
+                ++i;
+            }
         }
 
         return false;