@ballkidz/defifa 0.0.20 → 0.0.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ballkidz/defifa",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "license": "MIT",
   "engines": {
     "node": ">=20.0.0"
@@ -13,18 +13,18 @@
     "url": "https://github.com/BallKidz/defifa-collection-deployer"
   },
   "dependencies": {
-    "@bananapus/721-hook-v6": "^0.0.31",
-    "@bananapus/core-v6": "^0.0.31",
-    "@bananapus/permission-ids-v6": "^0.0.15",
-    "@croptop/core-v6": "^0.0.30",
+    "@bananapus/721-hook-v6": "^0.0.35",
+    "@bananapus/core-v6": "^0.0.34",
+    "@bananapus/permission-ids-v6": "^0.0.17",
+    "@croptop/core-v6": "^0.0.33",
     "@openzeppelin/contracts": "^5.6.1",
     "@prb/math": "^4.1.1",
-    "@rev-net/core-v6": "^0.0.28",
+    "@rev-net/core-v6": "^0.0.32",
     "scripty.sol": "^2.1.1"
   },
   "devDependencies": {
     "@bananapus/address-registry-v6": "^0.0.17",
-    "@sphinx-labs/plugins": "^0.33.1"
+    "@sphinx-labs/plugins": "^0.33.3"
   },
   "scripts": {
     "test": "forge test",

package/src/DefifaDeployer.sol

@@ -146,13 +146,13 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
         // Get a reference to the token being used by the project.
         address token = _opsOf[gameId].token;
 
-        // Get a reference to the terminal.
+        // Get a reference to the terminal via the directory.
         IJBTerminal terminal = CONTROLLER.DIRECTORY().primaryTerminalOf({projectId: gameId, token: token});
 
         // Get the accounting context for the project.
         JBAccountingContext memory context = terminal.accountingContextForTokenOf({projectId: gameId, token: token});
 
-        // Get the current balance.
+        // Get the current balance from the terminal's store.
         uint256 pot = IJBMultiTerminal(address(terminal)).STORE()
             .balanceOf({terminal: address(terminal), projectId: gameId, token: token});
 
@@ -221,9 +221,13 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
         // Get the game's current funding cycle along with its metadata.
         (JBRuleset memory currentRuleset, JBRulesetMetadata memory metadata) = CONTROLLER.currentRulesetOf(gameId);
 
-        if (currentRuleset.cycleNumber == 0) return DefifaGamePhase.COUNTDOWN;
-        if (currentRuleset.cycleNumber == 1) return DefifaGamePhase.MINT;
-        if (currentRuleset.cycleNumber == 2 && _opsOf[gameId].refundPeriodDuration != 0) {
+        // Cache the cycle number to avoid repeated memory reads.
+        uint256 cycleNumber = currentRuleset.cycleNumber;
+
+        // Return early for the first three phases based on cycle number.
+        if (cycleNumber == 0) return DefifaGamePhase.COUNTDOWN;
+        if (cycleNumber == 1) return DefifaGamePhase.MINT;
+        if (cycleNumber == 2 && _opsOf[gameId].refundPeriodDuration != 0) {
             return DefifaGamePhase.REFUND;
         }
 
@@ -234,7 +238,7 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
         // If no-contest has already been triggered, stay in NO_CONTEST.
         if (noContestTriggeredFor[gameId]) return DefifaGamePhase.NO_CONTEST;
 
-        // Get the game's ops data for the safety mechanism checks.
+        // Get the game's ops data for the safety mechanism checks. Cache to avoid repeated SLOAD.
         DefifaOpsData memory ops = _opsOf[gameId];
 
         // Check minimum participation threshold: if the treasury balance is below the threshold, the game is
@@ -660,8 +664,11 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
 
         // Sum all absolute percents.
         uint256 totalAbsolutePercent = nanaAbsolutePercent + defifaAbsolutePercent;
-        for (uint256 i; i < numberOfUserSplits; i++) {
+        for (uint256 i; i < numberOfUserSplits;) {
             totalAbsolutePercent += initialSplits[i].percent;
+            unchecked {
+                ++i;
+            }
         }
 
         // Validate that total fee splits don't exceed 100%.
@@ -677,7 +684,7 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
 
         // Normalize user splits and copy them over.
         uint256 normalizedTotal;
-        for (uint256 i; i < numberOfUserSplits; i++) {
+        for (uint256 i; i < numberOfUserSplits;) {
             splits[i] = initialSplits[i];
             splits[i].percent = uint32(
                 mulDiv({
@@ -685,6 +692,9 @@ contract DefifaDeployer is IDefifaDeployer, IDefifaGamePhaseReporter, IDefifaGam
                 })
             );
             normalizedTotal += splits[i].percent;
+            unchecked {
+                ++i;
+            }
         }
 
         // Add Defifa fee split (normalized).

package/src/DefifaGovernor.sol

@@ -136,6 +136,7 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
         // Keep a reference to the scorecard state.
         DefifaScorecardState state = stateOf({gameId: gameId, scorecardId: scorecardId});
 
+        // Attestations are only allowed during ACTIVE, SUCCEEDED, or QUEUED states.
         if (
             state != DefifaScorecardState.ACTIVE && state != DefifaScorecardState.SUCCEEDED
                 && state != DefifaScorecardState.QUEUED
@@ -188,10 +189,10 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
         // slither-disable-next-line unused-return
         (, JBRulesetMetadata memory metadata) = CONTROLLER.currentRulesetOf(gameId);
 
-        // Build the calldata to the target
+        // Build the calldata to the target.
         bytes memory scorecardCalldata = _buildScorecardCalldataFor(tierWeights);
 
-        // Attempt to execute the proposal.
+        // Hash the scorecard to derive its ID.
         scorecardId = _hashScorecardOf({gameHook: metadata.dataHook, calldataBytes: scorecardCalldata});
 
         // Make sure the proposal being ratified has succeeded.
@@ -222,7 +223,9 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
     /// @param scorecardId The ID of the scorecard to revoke attestation from.
     function revokeAttestationFrom(uint256 gameId, uint256 scorecardId) external virtual override {
         // Only allow revocation during ACTIVE phase.
-        if (stateOf(gameId, scorecardId) != DefifaScorecardState.ACTIVE) revert DefifaGovernor_NotAllowed();
+        if (stateOf({gameId: gameId, scorecardId: scorecardId}) != DefifaScorecardState.ACTIVE) {
+            revert DefifaGovernor_NotAllowed();
+        }
 
         DefifaAttestations storage attestations = _scorecardAttestationsOf[gameId][scorecardId];
         uint256 weight = attestations.attestedWeightOf[msg.sender];
@@ -256,7 +259,7 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
         // slither-disable-next-line incorrect-equality
         if (_packedScorecardInfoOf[gameId] == 0) revert DefifaGovernor_GameNotFound();
 
-        // Make sure no weight is assigned to an unowned tier.
+        // Keep a reference to the number of tier weights in the proposed scorecard.
         uint256 numberOfTierWeights = tierWeights.length;
 
         // Get the game's current funding cycle along with its metadata.
@@ -270,27 +273,31 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
 
         // If there's a weight assigned to the tier, make sure there is a token backed by it.
         // slither-disable-next-line calls-loop
-        for (uint256 i; i < numberOfTierWeights; i++) {
+        for (uint256 i; i < numberOfTierWeights;) {
             // A nonzero cashout weight is only valid once that tier has live ownership.
             // slither-disable-next-line calls-loop
             uint256 currentTierSupply = IDefifaHook(metadata.dataHook).currentSupplyOfTier(tierWeights[i].id);
             if (tierWeights[i].cashOutWeight > 0 && currentTierSupply == 0) {
                 revert DefifaGovernor_UnownedProposedCashoutValue();
             }
+            unchecked {
+                ++i;
+            }
         }
 
+        // Cache the hook store to avoid repeated external calls.
+        IJB721TiersHookStore hookStore = IDefifaHook(metadata.dataHook).store();
+
         // Run the same structural validation the hook will apply at ratification time so malformed
         // scorecards fail on submission instead of reaching a misleading SUCCEEDED state first.
         // slither-disable-next-line unused-return
-        DefifaHookLib.validateAndBuildWeights({
-            tierWeights: tierWeights, hookStore: IDefifaHook(metadata.dataHook).store(), hook: metadata.dataHook
-        });
+        DefifaHookLib.validateAndBuildWeights({tierWeights: tierWeights, hookStore: hookStore, hook: metadata.dataHook});
 
         // Hash the scorecard.
         scorecardId =
             _hashScorecardOf({gameHook: metadata.dataHook, calldataBytes: _buildScorecardCalldataFor(tierWeights)});
 
-        // Store the scorecard
+        // Store the scorecard.
         DefifaScorecard storage scorecard = _scorecardOf[gameId][scorecardId];
         if (scorecard.attestationsBegin != 0) revert DefifaGovernor_DuplicateScorecard();
 
@@ -308,8 +315,11 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
         scorecard.gracePeriodEnds = uint48(attestationsBegin + attestationGracePeriodOf(gameId));
 
         // Store tier weights for BWA computation.
-        for (uint256 i; i < numberOfTierWeights; i++) {
+        for (uint256 i; i < numberOfTierWeights;) {
             _scorecardTierWeightsOf[gameId][scorecardId][tierWeights[i].id - 1] = tierWeights[i].cashOutWeight;
+            unchecked {
+                ++i;
+            }
         }
 
         // Snapshot each tier's pending reserves and minted attestation units at submission time.
@@ -317,20 +327,25 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
         // after submission but before that checkpoint, clamp the live total back down to the minted
         // units that existed at submission and only then add the snapshotted pending reserves.
         {
-            IJB721TiersHookStore _store = IDefifaHook(metadata.dataHook).store();
-            uint256 _numberOfTiers = _store.maxTierIdOf(metadata.dataHook);
+            // Cache the number of tiers to avoid re-reading from storage.
+            uint256 numberOfTiers = hookStore.maxTierIdOf(metadata.dataHook);
             // slither-disable-next-line calls-loop
-            for (uint256 i; i < _numberOfTiers; i++) {
+            for (uint256 i; i < numberOfTiers;) {
                 uint256 tierId = i + 1;
                 // slither-disable-next-line calls-loop
-                JB721Tier memory tier = _store.tierOf({hook: metadata.dataHook, id: tierId, includeResolvedUri: false});
+                JB721Tier memory tier =
+                    hookStore.tierOf({hook: metadata.dataHook, id: tierId, includeResolvedUri: false});
                 // slither-disable-next-line calls-loop
-                uint256 pendingReserves = _store.numberOfPendingReservesFor(metadata.dataHook, tierId);
+                uint256 pendingReserves =
+                    hookStore.numberOfPendingReservesFor({hook: metadata.dataHook, tierId: tierId});
                 // slither-disable-next-line calls-loop
                 uint256 submittedTierAttestationUnits =
                     IDefifaHook(metadata.dataHook).currentSupplyOfTier(tierId) * tier.votingUnits;
                 _pendingReservesSnapshotOf[gameId][scorecardId][tierId] = pendingReserves;
                 _submittedTierAttestationUnitsOf[gameId][scorecardId][tierId] = submittedTierAttestationUnits;
+                unchecked {
+                    ++i;
+                }
             }
         }
 
@@ -351,8 +366,11 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
             // Find the largest tier weight.
             uint256 totalCashOutWeight = IDefifaHook(metadata.dataHook).TOTAL_CASHOUT_WEIGHT();
             uint256 maxWeight;
-            for (uint256 i; i < numberOfTierWeights; i++) {
+            for (uint256 i; i < numberOfTierWeights;) {
                 if (tierWeights[i].cashOutWeight > maxWeight) maxWeight = tierWeights[i].cashOutWeight;
+                unchecked {
+                    ++i;
+                }
             }
 
             // maxShare² in totalCashOutWeight scale (nonlinear: gentle for moderate, steep for extreme).
@@ -517,7 +535,7 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
         // Get a reference to the number of tiers.
         uint256 numberOfTiers = store.maxTierIdOf(metadata.dataHook);
 
-        for (uint256 i; i < numberOfTiers; i++) {
+        for (uint256 i; i < numberOfTiers;) {
             // Tiers are 1-indexed.
             uint256 tierId = i + 1;
 
@@ -537,7 +555,7 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
             // pending reserves decrease by the same amount — so no one's voting power shifts.
             {
                 // slither-disable-next-line calls-loop
-                uint256 pendingReserves = store.numberOfPendingReservesFor(metadata.dataHook, tierId);
+                uint256 pendingReserves = store.numberOfPendingReservesFor({hook: metadata.dataHook, tierId: tierId});
                 if (pendingReserves != 0) {
                     // slither-disable-next-line calls-loop
                     JB721Tier memory tier =
@@ -547,7 +565,7 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
             }
 
             // Scale the account's share of the tier to MAX_ATTESTATION_POWER_TIER.
-            // e.g. holding 3 of 10 tokens → 3/10 * MAX_ATTESTATION_POWER_TIER attestation power from this tier.
+            // e.g. holding 3 of 10 tokens -> 3/10 * MAX_ATTESTATION_POWER_TIER attestation power from this tier.
             unchecked {
                 if (tierAttestationUnitsForAccount != 0) {
                     attestationPower += mulDiv({
@@ -556,6 +574,7 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
                         denominator: tierTotalAttestationUnits
                     });
                 }
+                ++i;
             }
         }
     }
@@ -597,7 +616,7 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
         // Cache the total cashout weight denominator from the hook.
         uint256 totalCashOutWeight = hook.TOTAL_CASHOUT_WEIGHT();
 
-        for (uint256 i; i < numberOfTiers; i++) {
+        for (uint256 i; i < numberOfTiers;) {
             // Tiers are 1-indexed.
             uint256 tierId = i + 1;
 
@@ -614,10 +633,12 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
                 uint256 tierTotalAttestationUnits =
                     hook.getPastTierTotalAttestationUnitsOf({tier: tierId, timestamp: timestamp});
                 uint256 submittedTierAttestationUnits = _submittedTierAttestationUnitsOf[gameId][scorecardId][tierId];
+                // Clamp the total to the submitted snapshot to exclude post-submission reserve mints.
                 if (tierTotalAttestationUnits > submittedTierAttestationUnits) {
                     tierTotalAttestationUnits = submittedTierAttestationUnits;
                 }
 
+                // Add back the snapshotted pending reserves.
                 uint256 pendingReserves = _pendingReservesSnapshotOf[gameId][scorecardId][tierId];
                 if (pendingReserves != 0) {
                     // slither-disable-next-line calls-loop
@@ -627,14 +648,21 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
                 }
 
                 // Raw power for this tier.
-                uint256 rawPower =
-                    mulDiv(MAX_ATTESTATION_POWER_TIER, tierAttestationUnitsForAccount, tierTotalAttestationUnits);
+                uint256 rawPower = mulDiv({
+                    x: MAX_ATTESTATION_POWER_TIER,
+                    y: tierAttestationUnitsForAccount,
+                    denominator: tierTotalAttestationUnits
+                });
 
                 // BWA reduction: power * (1 - tierWeight / totalCashOutWeight).
                 uint256 tierWeight = _scorecardTierWeightsOf[gameId][scorecardId][i];
                 uint256 bwaMultiplier = totalCashOutWeight - tierWeight;
 
-                bwaAttestationPower += mulDiv(rawPower, bwaMultiplier, totalCashOutWeight);
+                bwaAttestationPower += mulDiv({x: rawPower, y: bwaMultiplier, denominator: totalCashOutWeight});
+            }
+
+            unchecked {
+                ++i;
             }
         }
     }
@@ -663,7 +691,7 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
         // Keep a reference to the total eligible tier weight.
         uint256 eligibleTierWeights;
 
-        for (uint256 i; i < numberOfTiers; i++) {
+        for (uint256 i; i < numberOfTiers;) {
             uint256 tierId = i + 1;
 
             // A tier contributes to quorum if it has circulating tokens OR unminted pending reserves.
@@ -673,10 +701,14 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
             // slither-disable-next-line calls-loop
             uint256 currentTierSupply = hook.currentSupplyOfTier(tierId);
             // slither-disable-next-line calls-loop
-            uint256 pendingReserves = store.numberOfPendingReservesFor(metadata.dataHook, tierId);
+            uint256 pendingReserves = store.numberOfPendingReservesFor({hook: metadata.dataHook, tierId: tierId});
             if (currentTierSupply != 0 || pendingReserves != 0) {
                 eligibleTierWeights += MAX_ATTESTATION_POWER_TIER;
             }
+
+            unchecked {
+                ++i;
+            }
         }
 
         // Quorum = 50% of all participated tiers' attestation power.
@@ -724,8 +756,8 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
 
         // If quorum has been reached (using the concentration-adjusted snapshot), check timelock.
         if (scorecard.quorumSnapshot <= _scorecardAttestationsOf[gameId][scorecardId].count) {
-            uint256 _timelockDuration = timelockDurationOf(gameId);
-            if (_timelockDuration > 0 && block.timestamp < uint256(scorecard.gracePeriodEnds) + _timelockDuration) {
+            uint256 timelockDur = timelockDurationOf(gameId);
+            if (timelockDur > 0 && block.timestamp < uint256(scorecard.gracePeriodEnds) + timelockDur) {
                 return DefifaScorecardState.QUEUED;
             }
             return DefifaScorecardState.SUCCEEDED;
@@ -749,7 +781,7 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
     // ----------------------- internal helpers -------------------------- //
     //*********************************************************************//
 
-    /// @notice Build the normalized calldata.
+    /// @notice Build the normalized calldata for ratification.
     /// @param tierWeights The weights of each tier in the scorecard data.
     /// @return The calldata to send alongside the transactions.
     function _buildScorecardCalldataFor(DefifaTierCashOutWeight[] calldata tierWeights)
@@ -757,7 +789,7 @@ contract DefifaGovernor is Ownable, IDefifaGovernor {
         pure
         returns (bytes memory)
     {
-        // Build the calldata from the tier weights.
+        // Build the calldata from the tier weights using the hook's selector.
         return abi.encodeWithSelector(DefifaHook.setTierCashOutWeightsTo.selector, (tierWeights));
     }
 

package/src/DefifaHook.sol

@@ -249,6 +249,7 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
     /// @return cashOutTaxRate The cash out tax rate influencing the reclaim amount.
     /// @return cashOutCount The amount of tokens that should be considered cashed out.
     /// @return totalSupply The total amount of tokens that are considered to be existing.
+    /// @return effectiveSurplusValue The effective surplus value to use for the cash out.
     /// @return hookSpecifications The amount and data to send to cash out hooks (this contract) instead of returning to
     /// the beneficiary.
     function beforeCashOutRecordedWith(JBBeforeCashOutRecordedContext calldata context)
@@ -260,6 +261,7 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
             uint256 cashOutTaxRate,
             uint256 cashOutCount,
             uint256 totalSupply,
+            uint256 effectiveSurplusValue,
             JBCashOutHookSpecification[] memory hookSpecifications
         )
     {
@@ -279,9 +281,12 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
         // Get the current game phase.
         DefifaGamePhase gamePhase = gamePhaseReporter.currentGamePhaseOf(context.projectId);
 
+        // Cache the store reference in a local variable to avoid repeated SLOAD.
+        IJB721TiersHookStore hookStore = store;
+
         // Calculate the amount paid to mint the tokens that are being burned.
         uint256 cumulativeMintPrice = DefifaHookLib.computeCumulativeMintPrice({
-            tokenIds: decodedTokenIds, hookStore: store, hook: address(this)
+            tokenIds: decodedTokenIds, hookStore: hookStore, hook: address(this)
         });
 
         // Use this contract as the only cash out hook.
@@ -301,6 +306,9 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
         // Use the surplus as the total supply.
         totalSupply = context.surplus.value;
 
+        // Use the surplus as the effective surplus value.
+        effectiveSurplusValue = context.surplus.value;
+
         // Use the cash out tax rate from the context.
         cashOutTaxRate = context.cashOutTaxRate;
     }
@@ -315,6 +323,7 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
         override
         returns (uint256 cumulativeWeight)
     {
+        // Cache the store in a local variable to avoid repeated SLOAD.
         cumulativeWeight = DefifaHookLib.computeCashOutWeightBatch({
             tokenIds: tokenIds,
             hookStore: store,
@@ -339,6 +348,7 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
 
     /// @notice The amount of tokens of a tier that are currently in circulation.
     /// @param tierId The ID of the tier to get the current supply of.
+    /// @return The current supply count.
     function currentSupplyOfTier(uint256 tierId) public view returns (uint256) {
         return DefifaHookLib.computeCurrentSupply({hookStore: store, hook: address(this), tierId: tierId});
     }
@@ -546,9 +556,12 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
                 (JBRulesetMetadataResolver.metadata(rulesets.currentOf(PROJECT_ID)))
             )) revert DefifaHook_ReservedTokenMintingPaused();
 
+        // Cache the store reference in a local variable to avoid repeated SLOAD.
+        IJB721TiersHookStore hookStore = store;
+
         // Keep a reference to the reserved token beneficiary.
         // slither-disable-next-line calls-loop
-        address reservedTokenBeneficiary = store.reserveBeneficiaryOf({hook: address(this), tierId: tierId});
+        address reservedTokenBeneficiary = hookStore.reserveBeneficiaryOf({hook: address(this), tierId: tierId});
 
         // Get a reference to the old delegate.
         address oldDelegate = _tierDelegation[reservedTokenBeneficiary][tierId];
@@ -566,14 +579,14 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
 
         // Record the minted reserves for the tier.
         // slither-disable-next-line calls-loop
-        uint256[] memory tokenIds = store.recordMintReservesFor({tierId: tierId, count: count});
+        uint256[] memory tokenIds = hookStore.recordMintReservesFor({tierId: tierId, count: count});
 
         // Keep a reference to the token ID being iterated on.
         uint256 tokenId;
 
         // Fetch the tier details (needed for votingUnits below).
         // slither-disable-next-line calls-loop
-        JB721Tier memory tier = store.tierOf({hook: address(this), id: tierId, includeResolvedUri: false});
+        JB721Tier memory tier = hookStore.tierOf({hook: address(this), id: tierId, includeResolvedUri: false});
 
         // Increment _totalMintCost so reserved recipients can claim their share of fee tokens ($DEFIFA/$NANA).
         // Note: reserved mints dilute existing fee token claimants because they increase the total mint cost
@@ -586,7 +599,7 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
             // Set the token ID.
             tokenId = tokenIds[i];
 
-            // Mint the token.
+            // Mint the token to the reserve beneficiary.
             // slither-disable-next-line reentrancy-no-eth
             _mint({to: reservedTokenBeneficiary, tokenId: tokenId});
 
@@ -647,26 +660,34 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
         // Keep track of whether the cashOut is happening during the complete phase.
         bool isComplete = gamePhaseReporter.currentGamePhaseOf(PROJECT_ID) == DefifaGamePhase.COMPLETE;
 
+        // Cache the store reference in a local variable to avoid repeated SLOAD in the loop.
+        IJB721TiersHookStore hookStore = store;
+
         // Iterate through all tokens, burning them if the owner is correct.
-        for (uint256 i; i < numberOfTokenIds; i++) {
+        for (uint256 i; i < numberOfTokenIds;) {
             // Set the token's ID.
             tokenId = decodedTokenIds[i];
 
             // Make sure the token's owner is correct.
             address tokenOwner = _ownerOf(tokenId);
             if (tokenOwner != context.holder) {
-                revert DefifaHook_Unauthorized(tokenId, tokenOwner, context.holder);
+                revert DefifaHook_Unauthorized({tokenId: tokenId, owner: tokenOwner, caller: context.holder});
             }
 
             // Burn the token.
             _burn(tokenId);
 
+            // Track per-tier redemptions during the complete phase.
             if (isComplete) {
                 unchecked {
                     // slither-disable-next-line reentrancy-no-eth,calls-loop
-                    ++tokensRedeemedFrom[store.tierIdOfToken(tokenId)];
+                    ++tokensRedeemedFrom[hookStore.tierIdOfToken(tokenId)];
                 }
             }
+
+            unchecked {
+                ++i;
+            }
         }
 
         // Call the hook.
@@ -800,17 +821,16 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
     /// cannot claim a disproportionate share before reserves are minted.
     /// @return cost The total mint cost of pending reserves.
     function _pendingReserveMintCost() internal view returns (uint256 cost) {
-        IJB721TiersHookStore _store = store;
-        address hook = address(this);
-        uint256 numberOfTiers = _store.maxTierIdOf(hook);
+        IJB721TiersHookStore hookStore = store;
+        uint256 numberOfTiers = hookStore.maxTierIdOf(address(this));
 
         for (uint256 i; i < numberOfTiers;) {
             uint256 tierId = i + 1;
             // slither-disable-next-line calls-loop
-            uint256 pendingReserves = _store.numberOfPendingReservesFor({hook: hook, tierId: tierId});
+            uint256 pendingReserves = hookStore.numberOfPendingReservesFor({hook: address(this), tierId: tierId});
             if (pendingReserves != 0) {
                 // slither-disable-next-line calls-loop
-                JB721Tier memory tier = _store.tierOf({hook: hook, id: tierId, includeResolvedUri: false});
+                JB721Tier memory tier = hookStore.tierOf({hook: address(this), id: tierId, includeResolvedUri: false});
                 cost += pendingReserves * tier.price;
             }
             unchecked {
@@ -1090,10 +1110,16 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
     /// @notice Before transferring an NFT, register its first owner (if necessary).
     /// @param to The address the NFT is being transferred to.
     /// @param tokenId The token ID of the NFT being transferred.
+    /// @param auth The address authorizing the transfer.
+    /// @return from The address the token was transferred from.
     function _update(address to, uint256 tokenId, address auth) internal virtual override returns (address from) {
+        // Cache the store reference in a local variable to avoid repeated SLOAD.
+        IJB721TiersHookStore hookStore = store;
+
         // Get a reference to the tier.
         // slither-disable-next-line calls-loop
-        JB721Tier memory tier = store.tierOfTokenId({hook: address(this), tokenId: tokenId, includeResolvedUri: false});
+        JB721Tier memory tier =
+            hookStore.tierOfTokenId({hook: address(this), tokenId: tokenId, includeResolvedUri: false});
 
         // Record the transfers and keep a reference to where the token is coming from.
         from = super._update(to, tokenId, auth);
@@ -1127,7 +1153,7 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
 
         // Record the transfer after local delegation state has been finalized.
         // slither-disable-next-line calls-loop
-        store.recordTransferForTier({tierId: tier.id, from: from, to: to});
+        hookStore.recordTransferForTier({tierId: tier.id, from: from, to: to});
 
         return from;
     }