@bananapus/core-v6 0.0.31 → 0.0.32

package/src/JBRulesets.sol

@@ -672,17 +672,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;
+            }
         }
     }
 
@@ -721,6 +723,7 @@ contract JBRulesets is JBControlled, IJBRulesets {
         }
 
         // Get a reference to the latest ruleset's struct.
+        // Note: full metadata is loaded because `_approvalStatusOf` forwards the struct to external approval hooks.
         JBRuleset memory baseRuleset = _getStructFor({projectId: projectId, rulesetId: latestId});
 
         // Get a reference to the approval status.
@@ -743,7 +746,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 = _getStructWithoutMetadataFor({projectId: projectId, rulesetId: baseRuleset.basedOnId});
         }
 
         // Make sure the ruleset starts after the base ruleset.
@@ -896,11 +901,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 +917,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 +934,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 = _getStructWithoutMetadataFor({projectId: projectId, rulesetId: rulesetId});
 
         // Loop through all most recently queued rulesets until an approvable one is found, or we've proven one can't
         // exist.
@@ -945,12 +951,64 @@ contract JBRulesets is JBControlled, IJBRulesets {
                 return ruleset.id;
             }
 
-            ruleset = _getStructFor({projectId: projectId, rulesetId: ruleset.basedOnId});
+            ruleset = _getStructWithoutMetadataFor({projectId: projectId, rulesetId: ruleset.basedOnId});
         } while (ruleset.cycleNumber != 0);
 
         return 0;
     }
 
+    /// @notice Unpack a ruleset's intrinsic and user properties without loading metadata.
+    /// @dev Saves one cold SLOAD (~2,100 gas) compared to `_getStructFor`. Use this for linked-list traversal where
+    /// only `id`, `start`, `duration`, `basedOnId`, `cycleNumber`, `weight`, `weightCutPercent`, and `approvalHook`
+    /// are needed.
+    /// @param projectId The ID of the project the ruleset belongs to.
+    /// @param rulesetId The ID of the ruleset to get the struct for.
+    /// @return ruleset A ruleset struct with `metadata` set to 0.
+    function _getStructWithoutMetadataFor(
+        uint256 projectId,
+        uint256 rulesetId
+    )
+        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;
+
+        // forge-lint: disable-next-line(unsafe-typecast)
+        ruleset.id = uint48(rulesetId);
+
+        uint256 packedIntrinsicProperties = _packedIntrinsicPropertiesOf[projectId][rulesetId];
+
+        // `weight` in bits 0-111 bits.
+        // forge-lint: disable-next-line(unsafe-typecast)
+        ruleset.weight = uint112(packedIntrinsicProperties);
+        // `basedOnId` in bits 112-159 bits.
+        // forge-lint: disable-next-line(unsafe-typecast)
+        ruleset.basedOnId = uint48(packedIntrinsicProperties >> 112);
+        // `start` in bits 160-207 bits.
+        // forge-lint: disable-next-line(unsafe-typecast)
+        ruleset.start = uint48(packedIntrinsicProperties >> 160);
+        // `cycleNumber` in bits 208-255 bits.
+        // forge-lint: disable-next-line(unsafe-typecast)
+        ruleset.cycleNumber = uint48(packedIntrinsicProperties >> 208);
+
+        uint256 packedUserProperties = _packedUserPropertiesOf[projectId][rulesetId];
+
+        // approval hook in bits 0-159 bits.
+        // forge-lint: disable-next-line(unsafe-typecast)
+        ruleset.approvalHook = IJBRulesetApprovalHook(address(uint160(packedUserProperties)));
+        // `duration` in bits 160-191 bits.
+        // forge-lint: disable-next-line(unsafe-typecast)
+        ruleset.duration = uint32(packedUserProperties >> 160);
+        // weight cut percent in bits 192-223 bits.
+        // forge-lint: disable-next-line(unsafe-typecast)
+        ruleset.weightCutPercent = uint32(packedUserProperties >> 192);
+
+        // metadata intentionally not loaded — saves one cold SLOAD (~2,100 gas).
+    }
+
     /// @notice Unpack a ruleset's packed stored values into an easy-to-work-with ruleset struct.
     /// @param projectId The ID of the project the ruleset belongs to.
     /// @param rulesetId The ID of the ruleset to get the full struct for.
@@ -1067,8 +1125,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 = _getStructWithoutMetadataFor({projectId: projectId, rulesetId: rulesetId});
 
         // There is no upcoming ruleset if the latest ruleset has already started.
         // slither-disable-next-line incorrect-equality
@@ -1086,7 +1144,7 @@ contract JBRulesets is JBControlled, IJBRulesets {
 
         // Find the base ruleset that is not still queued.
         while (true) {
-            baseRuleset = _getStructFor({projectId: projectId, rulesetId: basedOnId});
+            baseRuleset = _getStructWithoutMetadataFor({projectId: projectId, rulesetId: basedOnId});
 
             // If the base ruleset starts in the future,
             if (block.timestamp < baseRuleset.start) {
@@ -1100,8 +1158,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 = _getStructWithoutMetadataFor({projectId: projectId, rulesetId: rulesetId});
 
         // 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;

package/src/JBTerminalStore.sol

@@ -110,6 +110,9 @@ contract JBTerminalStore is IJBTerminalStore {
     /// @dev Increases as projects use their allowance.
     /// @dev The used surplus allowance is represented as a fixed point number with the same amount of decimals as the
     /// terminal it applies to.
+    /// @dev Surplus allowance usage is keyed by `ruleset.id`, not cycle number. Implicit cycle progression
+    /// (duration-based auto-cycling) does not reset allowance — this is by design. Projects must queue a new ruleset
+    /// to get a fresh allowance.
     /// @custom:param terminal The terminal the surplus allowance applies to.
     /// @custom:param projectId The ID of the project to get the used surplus allowance of.
     /// @custom:param token The token the surplus allowance applies to in the terminal.
@@ -172,7 +175,7 @@ contract JBTerminalStore is IJBTerminalStore {
         }
 
         // Record each accounting context.
-        for (uint256 i; i < contexts.length; i++) {
+        for (uint256 i; i < contexts.length;) {
             JBAccountingContext calldata context = contexts[i];
 
             // Make sure the token accounting context isn't already set.
@@ -213,6 +216,9 @@ contract JBTerminalStore is IJBTerminalStore {
 
             // Add the context to the list.
             _accountingContextsOf[msg.sender][projectId].push(context);
+            unchecked {
+                ++i;
+            }
         }
     }
 
@@ -277,26 +283,29 @@ contract JBTerminalStore is IJBTerminalStore {
 
         if (hookSpecifications.length != 0) {
             uint256 numberOfSpecifications = hookSpecifications.length;
-            for (uint256 i; i < numberOfSpecifications; i++) {
+            for (uint256 i; i < numberOfSpecifications;) {
                 uint256 specificationAmount = hookSpecifications[i].amount;
                 if (specificationAmount != 0) {
                     balanceDiff += specificationAmount;
                 }
+                unchecked {
+                    ++i;
+                }
             }
         }
 
+        // Cache the balance slot to avoid redundant storage reads.
+        uint256 currentBalance = balanceOf[msg.sender][projectId][tokenToReclaim];
+
         // The amount being reclaimed must be within the project's balance.
-        if (balanceDiff > balanceOf[msg.sender][projectId][tokenToReclaim]) {
-            revert JBTerminalStore_InadequateTerminalStoreBalance(
-                balanceDiff, balanceOf[msg.sender][projectId][tokenToReclaim]
-            );
+        if (balanceDiff > currentBalance) {
+            revert JBTerminalStore_InadequateTerminalStoreBalance(balanceDiff, currentBalance);
         }
 
         // Remove the reclaimed funds from the project's balance.
         if (balanceDiff != 0) {
             unchecked {
-                balanceOf[msg.sender][projectId][tokenToReclaim] =
-                    balanceOf[msg.sender][projectId][tokenToReclaim] - balanceDiff;
+                balanceOf[msg.sender][projectId][tokenToReclaim] = currentBalance - balanceDiff;
             }
         }
     }
@@ -338,8 +347,9 @@ contract JBTerminalStore is IJBTerminalStore {
 
         // Add the correct balance difference to the token balance of the project.
         if (balanceDiff != 0) {
-            balanceOf[msg.sender][projectId][amount.token] =
-                balanceOf[msg.sender][projectId][amount.token] + balanceDiff;
+            // Cache the balance slot to avoid redundant storage reads.
+            uint256 currentBalance = balanceOf[msg.sender][projectId][amount.token];
+            balanceOf[msg.sender][projectId][amount.token] = currentBalance + balanceDiff;
         }
     }
 
@@ -385,26 +395,20 @@ contract JBTerminalStore is IJBTerminalStore {
                 })
             });
 
-        // The amount being paid out must be available.
-        if (amountPaidOut > balanceOf[msg.sender][projectId][token]) {
-            revert JBTerminalStore_InadequateTerminalStoreBalance(
-                amountPaidOut, balanceOf[msg.sender][projectId][token]
-            );
-        }
+        // Cache the balance slot to avoid redundant storage reads.
+        uint256 currentBalance = balanceOf[msg.sender][projectId][token];
 
-        // Removed the paid out funds from the project's token balance.
-        unchecked {
-            balanceOf[msg.sender][projectId][token] = balanceOf[msg.sender][projectId][token] - amountPaidOut;
+        // The amount being paid out must be available.
+        if (amountPaidOut > currentBalance) {
+            revert JBTerminalStore_InadequateTerminalStoreBalance(amountPaidOut, currentBalance);
         }
 
         // The new total amount which has been paid out during this ruleset.
         uint256 newUsedPayoutLimitOf =
             usedPayoutLimitOf[msg.sender][projectId][token][ruleset.cycleNumber][currency] + amount;
 
-        // Store the new amount.
-        usedPayoutLimitOf[msg.sender][projectId][token][ruleset.cycleNumber][currency] = newUsedPayoutLimitOf;
-
         // Amount must be within what is still available to pay out.
+        // Validate BEFORE writing to storage to avoid wasting gas on SSTORE when the tx will revert.
         uint256 payoutLimit = IJBController(address(DIRECTORY.controllerOf(projectId))).FUND_ACCESS_LIMITS()
             .payoutLimitOf({
                 projectId: projectId, rulesetId: ruleset.id, terminal: msg.sender, token: token, currency: currency
@@ -414,6 +418,14 @@ contract JBTerminalStore is IJBTerminalStore {
         if (newUsedPayoutLimitOf > payoutLimit || payoutLimit == 0) {
             revert JBTerminalStore_InadequateControllerPayoutLimit(newUsedPayoutLimitOf, payoutLimit);
         }
+
+        // Removed the paid out funds from the project's token balance.
+        unchecked {
+            balanceOf[msg.sender][projectId][token] = currentBalance - amountPaidOut;
+        }
+
+        // Store the new used payout limit.
+        usedPayoutLimitOf[msg.sender][projectId][token][ruleset.cycleNumber][currency] = newUsedPayoutLimitOf;
     }
 
     /// @notice Records the migration of funds from this store.
@@ -493,17 +505,12 @@ contract JBTerminalStore is IJBTerminalStore {
         // The amount being used must be available in the surplus.
         if (usedAmount > surplus) revert JBTerminalStore_InadequateTerminalStoreBalance(usedAmount, surplus);
 
-        // Update the project's balance.
-        balanceOf[msg.sender][projectId][token] = balanceOf[msg.sender][projectId][token] - usedAmount;
-
         // Get a reference to the new used surplus allowance for this ruleset ID.
         uint256 newUsedSurplusAllowanceOf =
             usedSurplusAllowanceOf[msg.sender][projectId][token][ruleset.id][currency] + amount;
 
-        // Store the incremented value.
-        usedSurplusAllowanceOf[msg.sender][projectId][token][ruleset.id][currency] = newUsedSurplusAllowanceOf;
-
         // There must be sufficient surplus allowance available.
+        // Validate BEFORE writing to storage to avoid wasting gas on SSTORE when the tx will revert.
         uint256 surplusAllowance = IJBController(address(DIRECTORY.controllerOf(projectId))).FUND_ACCESS_LIMITS()
             .surplusAllowanceOf({
                 projectId: projectId, rulesetId: ruleset.id, terminal: msg.sender, token: token, currency: currency
@@ -513,6 +520,15 @@ contract JBTerminalStore is IJBTerminalStore {
         if (newUsedSurplusAllowanceOf > surplusAllowance || surplusAllowance == 0) {
             revert JBTerminalStore_InadequateControllerAllowance(newUsedSurplusAllowanceOf, surplusAllowance);
         }
+
+        // Cache the balance slot to avoid redundant storage reads.
+        uint256 currentBalance = balanceOf[msg.sender][projectId][token];
+
+        // Update the project's balance.
+        balanceOf[msg.sender][projectId][token] = currentBalance - usedAmount;
+
+        // Store the incremented value.
+        usedSurplusAllowanceOf[msg.sender][projectId][token][ruleset.id][currency] = newUsedSurplusAllowanceOf;
     }
 
     //*********************************************************************//
@@ -774,9 +790,17 @@ contract JBTerminalStore is IJBTerminalStore {
         override
         returns (uint256)
     {
+        // Fetch the current ruleset once — used for both surplus calculation and cash out tax rate.
+        JBRuleset memory ruleset = RULESETS.currentOf(projectId);
+
         // Aggregate surplus across the terminals, optionally filtered by the specified tokens.
         uint256 currentSurplus = _currentSurplusOf({
-            projectId: projectId, terminals: terminals, tokens: tokens, decimals: decimals, currency: currency
+            projectId: projectId,
+            terminals: terminals,
+            tokens: tokens,
+            decimals: decimals,
+            currency: currency,
+            ruleset: ruleset
         });
 
         // If there's no surplus, nothing can be reclaimed.
@@ -789,15 +813,12 @@ contract JBTerminalStore is IJBTerminalStore {
         // Can't cash out more tokens than are in the total supply.
         if (cashOutCount > totalSupply) return 0;
 
-        // Get the cash out tax rate from the current ruleset.
-        uint256 cashOutTaxRate = RULESETS.currentOf(projectId).cashOutTaxRate();
-
         // Return the amount of surplus terminal tokens that would be reclaimed.
         return JBCashOuts.cashOutFrom({
             surplus: currentSurplus,
             cashOutCount: cashOutCount,
             totalSupply: totalSupply,
-            cashOutTaxRate: cashOutTaxRate
+            cashOutTaxRate: ruleset.cashOutTaxRate()
         });
     }
 
@@ -806,6 +827,9 @@ contract JBTerminalStore is IJBTerminalStore {
     //*********************************************************************//
 
     /// @notice Computes the surplus relevant for a cash out (total or local, depending on ruleset flag).
+    /// @dev When `useTotalSurplusForCashOuts` is enabled, surplus is aggregated from ALL registered terminals without
+    /// validation. Projects MUST only register trusted terminals — an untrusted terminal can over-report surplus and
+    /// cause the executing terminal to overpay cash-outs.
     /// @param terminal The terminal the cash out is being recorded from.
     /// @param projectId The ID of the project being cashed out from.
     /// @param tokenToReclaim The token being reclaimed.
@@ -937,10 +961,13 @@ contract JBTerminalStore is IJBTerminalStore {
                 IJBRulesetDataHook(ruleset.dataHook()).beforeCashOutRecordedWith(context);
 
             // Noop specifications are informational only, so they can't also request forwarded funds.
-            for (uint256 i; i < hookSpecifications.length; i++) {
+            for (uint256 i; i < hookSpecifications.length;) {
                 if (hookSpecifications[i].noop && hookSpecifications[i].amount != 0) {
                     revert JBTerminalStore_NoopHookSpecHasAmount(hookSpecifications[i].amount);
                 }
+                unchecked {
+                    ++i;
+                }
             }
         } else {
             cashOutTaxRate = ruleset.cashOutTaxRate();
@@ -1028,7 +1055,7 @@ contract JBTerminalStore is IJBTerminalStore {
         balanceDiff = amount.value;
 
         // Ensure that the specifications have valid amounts.
-        for (uint256 i; i < hookSpecifications.length; i++) {
+        for (uint256 i; i < hookSpecifications.length;) {
             if (hookSpecifications[i].noop && hookSpecifications[i].amount != 0) {
                 revert JBTerminalStore_NoopHookSpecHasAmount(hookSpecifications[i].amount);
             }
@@ -1044,6 +1071,9 @@ contract JBTerminalStore is IJBTerminalStore {
                 // Decrement the total amount being added to the local balance.
                 balanceDiff -= specifiedAmount;
             }
+            unchecked {
+                ++i;
+            }
         }
 
         // If there's no amount being recorded, there's nothing left to do.
@@ -1086,15 +1116,46 @@ contract JBTerminalStore is IJBTerminalStore {
         internal
         view
         returns (uint256 surplus)
+    {
+        // Fetch the ruleset once and delegate to the overload that accepts it.
+        return _currentSurplusOf({
+            projectId: projectId,
+            terminals: terminals,
+            tokens: tokens,
+            decimals: decimals,
+            currency: currency,
+            ruleset: RULESETS.currentOf(projectId)
+        });
+    }
+
+    /// @notice Gets the current surplus amount for a project across specified terminals and tokens, using a
+    /// pre-fetched ruleset.
+    /// @dev Use this overload when the caller already has the current ruleset to avoid a redundant
+    /// `RULESETS.currentOf()` call.
+    /// @param projectId The ID of the project to get surplus for.
+    /// @param terminals The terminals to include. If empty, all project terminals are used.
+    /// @param tokens The tokens to include. If empty, all tokens per terminal are used.
+    /// @param decimals The number of decimals to expect in the resulting fixed point number.
+    /// @param currency The currency the resulting amount should be in terms of.
+    /// @param ruleset The project's current ruleset.
+    /// @return surplus The current surplus amount.
+    function _currentSurplusOf(
+        uint256 projectId,
+        IJBTerminal[] memory terminals,
+        address[] memory tokens,
+        uint256 decimals,
+        uint256 currency,
+        JBRuleset memory ruleset
+    )
+        internal
+        view
+        returns (uint256 surplus)
     {
         // If specific terminals were provided, use them. Otherwise, get all terminals from the directory.
         IJBTerminal[] memory resolvedTerminals = terminals.length != 0 ? terminals : DIRECTORY.terminalsOf(projectId);
 
-        // The ruleset determines payout limits, which affect surplus. Fetch it once for all terminals.
-        JBRuleset memory ruleset = RULESETS.currentOf(projectId);
-
         // Sum surplus across each terminal.
-        for (uint256 i; i < resolvedTerminals.length; i++) {
+        for (uint256 i; i < resolvedTerminals.length;) {
             address terminal = address(resolvedTerminals[i]);
 
             // Build the list of accounting contexts to include in this terminal's surplus calculation.
@@ -1102,8 +1163,11 @@ contract JBTerminalStore is IJBTerminalStore {
             if (tokens.length != 0) {
                 // Specific tokens requested: look up each token's accounting context at this terminal.
                 accountingContexts = new JBAccountingContext[](tokens.length);
-                for (uint256 j; j < tokens.length; j++) {
+                for (uint256 j; j < tokens.length;) {
                     accountingContexts[j] = _accountingContextForTokenOf[terminal][projectId][tokens[j]];
+                    unchecked {
+                        ++j;
+                    }
                 }
             } else {
                 // No token filter: use all accounting contexts registered at this terminal.
@@ -1119,6 +1183,9 @@ contract JBTerminalStore is IJBTerminalStore {
                 targetDecimals: decimals,
                 targetCurrency: currency
             });
+            unchecked {
+                ++i;
+            }
         }
     }
 
@@ -1151,7 +1218,7 @@ contract JBTerminalStore is IJBTerminalStore {
         uint256 numberOfTokenAccountingContexts = accountingContexts.length;
 
         // Add payout limits from each token.
-        for (uint256 i; i < numberOfTokenAccountingContexts; i++) {
+        for (uint256 i; i < numberOfTokenAccountingContexts;) {
             uint256 tokenSurplus = _tokenSurplusFrom({
                 terminal: terminal,
                 projectId: projectId,
@@ -1162,6 +1229,9 @@ contract JBTerminalStore is IJBTerminalStore {
             });
             // Increment the surplus with any remaining balance.
             if (tokenSurplus > 0) surplus += tokenSurplus;
+            unchecked {
+                ++i;
+            }
         }
     }
 
@@ -1228,7 +1298,7 @@ contract JBTerminalStore is IJBTerminalStore {
         uint256 numberOfPayoutLimits = payoutLimits.length;
 
         // Loop through each payout limit to determine the cumulative normalized payout limit remaining.
-        for (uint256 i; i < numberOfPayoutLimits; i++) {
+        for (uint256 i; i < numberOfPayoutLimits;) {
             JBCurrencyAmount memory payoutLimit = payoutLimits[i];
 
             // Set the payout limit value to the amount still available to pay out during the ruleset.
@@ -1280,6 +1350,9 @@ contract JBTerminalStore is IJBTerminalStore {
             } else {
                 return 0;
             }
+            unchecked {
+                ++i;
+            }
         }
     }
 }

package/src/JBTokens.sol

@@ -253,9 +253,12 @@ contract JBTokens is JBControlled, IJBTokens {
         // Save a reference to whether there a token exists.
         bool tokensWereClaimed = token != IJBToken(address(0));
 
+        // Cache the total supply to avoid a redundant external call on revert.
+        uint256 supply = totalSupplyOf(projectId);
+
         // The total supply after minting can't exceed the maximum value storable in a uint208.
-        if (totalSupplyOf(projectId) + count > type(uint208).max) {
-            revert JBTokens_OverflowAlert(totalSupplyOf(projectId) + count, type(uint208).max);
+        if (supply + count > type(uint208).max) {
+            revert JBTokens_OverflowAlert(supply + count, type(uint208).max);
         }
 
         if (tokensWereClaimed) {