@ballkidz/defifa 0.0.11 → 0.0.13

package/src/DefifaHook.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.26;
+pragma solidity 0.8.28;
 
 import {Checkpoints} from "@openzeppelin/contracts/utils/structs/Checkpoints.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
@@ -161,10 +161,10 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
     /// @return The first owner of the token.
     function firstOwnerOf(uint256 tokenId) external view override returns (address) {
         // Get a reference to the first owner.
-        address _storedFirstOwner = _firstOwnerOf[tokenId];
+        address storedFirstOwner = _firstOwnerOf[tokenId];
 
         // If the stored first owner is set, return it.
-        if (_storedFirstOwner != address(0)) return _storedFirstOwner;
+        if (storedFirstOwner != address(0)) return storedFirstOwner;
 
         // Otherwise, the first owner must be the current owner.
         return _owners[tokenId];
@@ -275,23 +275,22 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
         if (metadataExists) decodedTokenIds = abi.decode(metadata, (uint256[]));
 
         // Get the current game phase.
-        DefifaGamePhase _gamePhase = gamePhaseReporter.currentGamePhaseOf(context.projectId);
+        DefifaGamePhase gamePhase = gamePhaseReporter.currentGamePhaseOf(context.projectId);
 
         // Calculate the amount paid to mint the tokens that are being burned.
-        uint256 _cumulativeMintPrice = DefifaHookLib.computeCumulativeMintPrice({
+        uint256 cumulativeMintPrice = DefifaHookLib.computeCumulativeMintPrice({
             tokenIds: decodedTokenIds, hookStore: store, hook: address(this)
         });
 
         // Use this contract as the only cash out hook.
         hookSpecifications = new JBCashOutHookSpecification[](1);
-        hookSpecifications[0] = JBCashOutHookSpecification({
-            hook: this, noop: false, amount: 0, metadata: abi.encode(_cumulativeMintPrice)
-        });
+        hookSpecifications[0] =
+            JBCashOutHookSpecification({hook: this, noop: false, amount: 0, metadata: abi.encode(cumulativeMintPrice)});
 
         // Compute the cash out count based on the game phase.
         cashOutCount = DefifaHookLib.computeCashOutCount({
-            gamePhase: _gamePhase,
-            cumulativeMintPrice: _cumulativeMintPrice,
+            gamePhase: gamePhase,
+            cumulativeMintPrice: cumulativeMintPrice,
             surplusValue: context.surplus.value,
             totalAmountRedeemed: amountRedeemed,
             cumulativeCashOutWeight: cashOutWeightOf(decodedTokenIds)
@@ -516,15 +515,15 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
         _store.recordAddTiers(_tiers);
 
         // Keep a reference to the number of tier names.
-        uint256 _numberOfTierNames = _tierNames.length;
+        uint256 numberOfTierNames = _tierNames.length;
 
         // Set the name for each tier.
-        for (uint256 _i; _i < _numberOfTierNames;) {
+        for (uint256 i; i < numberOfTierNames;) {
             // Set the tier name.
-            _tierNameOf[_i + 1] = _tierNames[_i];
+            _tierNameOf[i + 1] = _tierNames[i];
 
             unchecked {
-                ++_i;
+                ++i;
             }
         }
 
@@ -543,57 +542,54 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
             )) revert DefifaHook_ReservedTokenMintingPaused();
 
         // Keep a reference to the reserved token beneficiary.
-        address _reservedTokenBeneficiary = store.reserveBeneficiaryOf({hook: address(this), tierId: tierId});
+        address reservedTokenBeneficiary = store.reserveBeneficiaryOf({hook: address(this), tierId: tierId});
 
         // Get a reference to the old delegate.
-        address _oldDelegate = _tierDelegation[_reservedTokenBeneficiary][tierId];
+        address oldDelegate = _tierDelegation[reservedTokenBeneficiary][tierId];
 
         // Set the delegate as the beneficiary if the beneficiary hasn't already set a delegate.
-        if (_oldDelegate == address(0)) {
+        if (oldDelegate == address(0)) {
             _delegateTier({
-                _account: _reservedTokenBeneficiary,
-                _delegatee: defaultAttestationDelegate != address(0)
+                account: reservedTokenBeneficiary,
+                delegatee: defaultAttestationDelegate != address(0)
                     ? defaultAttestationDelegate
-                    : _reservedTokenBeneficiary,
-                _tierId: tierId
+                    : reservedTokenBeneficiary,
+                tierId: tierId
             });
         }
 
         // Record the minted reserves for the tier.
-        uint256[] memory _tokenIds = store.recordMintReservesFor({tierId: tierId, count: count});
+        uint256[] memory tokenIds = store.recordMintReservesFor({tierId: tierId, count: count});
 
         // Keep a reference to the token ID being iterated on.
-        uint256 _tokenId;
+        uint256 tokenId;
 
         // Fetch the tier details (needed for votingUnits below).
-        JB721Tier memory _tier = store.tierOf({hook: address(this), id: tierId, includeResolvedUri: false});
+        JB721Tier memory tier = store.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
         // denominator without contributing new funds to the fee token balances. This is the intended design —
         // reserved recipients receive a proportional claim on fee tokens as if they had paid to mint.
-        _totalMintCost += _tier.price * count;
+        _totalMintCost += tier.price * count;
 
-        for (uint256 _i; _i < count;) {
+        for (uint256 i; i < count;) {
             // Set the token ID.
-            _tokenId = _tokenIds[_i];
+            tokenId = tokenIds[i];
 
             // Mint the token.
-            _mint({to: _reservedTokenBeneficiary, tokenId: _tokenId});
+            _mint({to: reservedTokenBeneficiary, tokenId: tokenId});
 
-            emit MintReservedToken(_tokenId, tierId, _reservedTokenBeneficiary, msg.sender);
+            emit MintReservedToken(tokenId, tierId, reservedTokenBeneficiary, msg.sender);
 
             unchecked {
-                ++_i;
+                ++i;
             }
         }
 
         // Transfer the attestation units to the delegate.
         _transferTierAttestationUnits({
-            _from: address(0),
-            _to: _reservedTokenBeneficiary,
-            _tierId: tierId,
-            _amount: _tier.votingUnits * _tokenIds.length
+            from: address(0), to: reservedTokenBeneficiary, tierId: tierId, amount: tier.votingUnits * tokenIds.length
         });
     }
 
@@ -630,52 +626,52 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
         }
 
         // Decode the CashOut metadata.
-        (uint256[] memory _decodedTokenIds) = abi.decode(metadata, (uint256[]));
+        (uint256[] memory decodedTokenIds) = abi.decode(metadata, (uint256[]));
 
         // Get a reference to the number of token IDs being checked.
-        uint256 _numberOfTokenIds = _decodedTokenIds.length;
+        uint256 numberOfTokenIds = decodedTokenIds.length;
 
         // Keep a reference to the token ID being iterated on.
-        uint256 _tokenId;
+        uint256 tokenId;
 
         // Keep track of whether the cashOut is happening during the complete phase.
-        bool _isComplete = gamePhaseReporter.currentGamePhaseOf(PROJECT_ID) == DefifaGamePhase.COMPLETE;
+        bool isComplete = gamePhaseReporter.currentGamePhaseOf(PROJECT_ID) == DefifaGamePhase.COMPLETE;
 
         // Iterate through all tokens, burning them if the owner is correct.
-        for (uint256 _i; _i < _numberOfTokenIds; _i++) {
+        for (uint256 i; i < numberOfTokenIds; i++) {
             // Set the token's ID.
-            _tokenId = _decodedTokenIds[_i];
+            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);
+            address tokenOwner = _ownerOf(tokenId);
+            if (tokenOwner != context.holder) {
+                revert DefifaHook_Unauthorized(tokenId, tokenOwner, context.holder);
             }
 
             // Burn the token.
-            _burn(_tokenId);
+            _burn(tokenId);
 
-            if (_isComplete) {
+            if (isComplete) {
                 unchecked {
-                    ++tokensRedeemedFrom[store.tierIdOfToken(_tokenId)];
+                    ++tokensRedeemedFrom[store.tierIdOfToken(tokenId)];
                 }
             }
         }
 
         // Call the hook.
-        _didBurn(_decodedTokenIds);
+        _didBurn(decodedTokenIds);
 
         // Decode the metadata passed by the hook.
-        (uint256 _cumulativeMintPrice) = abi.decode(context.hookMetadata, (uint256));
+        (uint256 cumulativeMintPrice) = abi.decode(context.hookMetadata, (uint256));
 
         // Increment the amount redeemed if this is the complete phase.
-        bool _beneficiaryReceivedTokens;
-        if (_isComplete) {
+        bool beneficiaryReceivedTokens;
+        if (isComplete) {
             amountRedeemed += context.reclaimedAmount.value;
 
             // Claim the $DEFIFA and $NANA tokens for the user.
-            _beneficiaryReceivedTokens = _claimTokensFor({
-                _beneficiary: context.holder, shareToBeneficiary: _cumulativeMintPrice, outOfTotal: _totalMintCost
+            beneficiaryReceivedTokens = _claimTokensFor({
+                beneficiary: context.holder, shareToBeneficiary: cumulativeMintPrice, outOfTotal: _totalMintCost
             });
         }
 
@@ -683,27 +679,27 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
         // Tokens in 0-weight tiers (losing teams) cannot burn to reclaim fees if no fee tokens were
         // distributed. This is correct behavior — 0-weight means the tier has no claim on the pot. Burning would
         // return 0 value regardless.
-        if (context.reclaimedAmount.value == 0 && !_beneficiaryReceivedTokens) revert DefifaHook_NothingToClaim();
+        if (context.reclaimedAmount.value == 0 && !beneficiaryReceivedTokens) revert DefifaHook_NothingToClaim();
 
         // Decrement the paid mint cost by the cumulative mint price of the tokens being burned.
-        _totalMintCost -= _cumulativeMintPrice;
+        _totalMintCost -= cumulativeMintPrice;
     }
 
     /// @notice Mint reserved tokens within the tier for the provided value.
     /// @param mintReservesForTiersData Contains information about how many reserved tokens to mint for each tier.
     function mintReservesFor(JB721TiersMintReservesConfig[] calldata mintReservesForTiersData) external override {
         // Keep a reference to the number of tiers there are to mint reserves for.
-        uint256 _numberOfTiers = mintReservesForTiersData.length;
+        uint256 numberOfTiers = mintReservesForTiersData.length;
 
-        for (uint256 _i; _i < _numberOfTiers;) {
+        for (uint256 i; i < numberOfTiers;) {
             // Get a reference to the data being iterated on.
-            JB721TiersMintReservesConfig memory _data = mintReservesForTiersData[_i];
+            JB721TiersMintReservesConfig memory data = mintReservesForTiersData[i];
 
             // Mint for the tier.
-            mintReservesFor(_data.tierId, _data.count);
+            mintReservesFor(data.tierId, data.count);
 
             unchecked {
-                ++_i;
+                ++i;
             }
         }
     }
@@ -713,10 +709,10 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
     /// @param tierWeights The tier weights to set.
     function setTierCashOutWeightsTo(DefifaTierCashOutWeight[] memory tierWeights) external override onlyOwner {
         // Get a reference to the game phase.
-        DefifaGamePhase _gamePhase = gamePhaseReporter.currentGamePhaseOf(PROJECT_ID);
+        DefifaGamePhase gamePhase = gamePhaseReporter.currentGamePhaseOf(PROJECT_ID);
 
         // Make sure the game has ended.
-        if (_gamePhase != DefifaGamePhase.SCORING) {
+        if (gamePhase != DefifaGamePhase.SCORING) {
             revert DefifaHook_GameIsntScoringYet();
         }
 
@@ -745,7 +741,7 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
             revert DefifaHook_DelegateChangesUnavailableInThisPhase();
         }
 
-        _delegateTier({_account: msg.sender, _delegatee: delegatee, _tierId: tierId});
+        _delegateTier({account: msg.sender, delegatee: delegatee, tierId: tierId});
     }
 
     /// @notice Delegate attestations.
@@ -757,22 +753,22 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
         }
 
         // Keep a reference to the number of tier delegates.
-        uint256 _numberOfTierDelegates = delegations.length;
+        uint256 numberOfTierDelegates = delegations.length;
 
         // Keep a reference to the data being iterated on.
-        DefifaDelegation memory _data;
+        DefifaDelegation memory data;
 
-        for (uint256 _i; _i < _numberOfTierDelegates;) {
+        for (uint256 i; i < numberOfTierDelegates;) {
             // Reference the data being iterated on.
-            _data = delegations[_i];
+            data = delegations[i];
 
             // Make sure a delegate is specified.
-            if (_data.delegatee == address(0)) revert DefifaHook_DelegateAddressZero();
+            if (data.delegatee == address(0)) revert DefifaHook_DelegateAddressZero();
 
-            _delegateTier({_account: msg.sender, _delegatee: _data.delegatee, _tierId: _data.tierId});
+            _delegateTier({account: msg.sender, delegatee: data.delegatee, tierId: data.tierId});
 
             unchecked {
-                ++_i;
+                ++i;
             }
         }
     }
@@ -782,12 +778,12 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
     //*********************************************************************//
 
     /// @notice Claims the defifa and base protocol tokens for a beneficiary.
-    /// @param _beneficiary The address to claim tokens for.
+    /// @param beneficiary The address to claim tokens for.
     /// @param shareToBeneficiary The share relative to the `outOfTotal` to send the user.
     /// @param outOfTotal The total share that the `shareToBeneficiary` is relative to.
     /// @return beneficiaryReceivedTokens A flag indicating if the beneficiary received any tokens.
     function _claimTokensFor(
-        address _beneficiary,
+        address beneficiary,
         uint256 shareToBeneficiary,
         uint256 outOfTotal
     )
@@ -795,7 +791,7 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
         returns (bool beneficiaryReceivedTokens)
     {
         return DefifaHookLib.claimTokensFor({
-            beneficiary: _beneficiary,
+            beneficiary: beneficiary,
             shareToBeneficiary: shareToBeneficiary,
             outOfTotal: outOfTotal,
             defifaToken: DEFIFA_TOKEN,
@@ -804,130 +800,130 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
     }
 
     /// @notice Delegate all attestation units for the specified tier.
-    /// @param _account The account delegating tier attestation units.
-    /// @param _delegatee The account to delegate tier attestation units to.
-    /// @param _tierId The ID of the tier for which attestation units are being transferred.
-    function _delegateTier(address _account, address _delegatee, uint256 _tierId) internal virtual {
+    /// @param account The account delegating tier attestation units.
+    /// @param delegatee The account to delegate tier attestation units to.
+    /// @param tierId The ID of the tier for which attestation units are being transferred.
+    function _delegateTier(address account, address delegatee, uint256 tierId) internal virtual {
         // Get the current delegatee
-        address _oldDelegate = _tierDelegation[_account][_tierId];
+        address oldDelegate = _tierDelegation[account][tierId];
 
         // Store the new delegatee
-        _tierDelegation[_account][_tierId] = _delegatee;
+        _tierDelegation[account][tierId] = delegatee;
 
-        emit DelegateChanged(_account, _oldDelegate, _delegatee);
+        emit DelegateChanged(account, oldDelegate, delegatee);
 
         // Move the attestations.
         _moveTierDelegateAttestations({
-            _from: _oldDelegate,
-            _to: _delegatee,
-            _tierId: _tierId,
-            _amount: _getTierAttestationUnits({_account: _account, _tierId: _tierId})
+            from: oldDelegate,
+            to: delegatee,
+            tierId: tierId,
+            amount: _getTierAttestationUnits({account: account, tierId: tierId})
         });
     }
 
     /// @notice A function that will run when tokens are burned via cashOut.
-    /// @param _tokenIds The IDs of the tokens that were burned.
-    function _didBurn(uint256[] memory _tokenIds) internal virtual override {
+    /// @param tokenIds The IDs of the tokens that were burned.
+    function _didBurn(uint256[] memory tokenIds) internal virtual override {
         // Add to burned counter.
-        store.recordBurn(_tokenIds);
+        store.recordBurn(tokenIds);
     }
 
     /// @notice Gets the amount of attestation units an address has for a particular tier.
-    /// @param _account The account to get attestation units for.
-    /// @param _tierId The ID of the tier to get attestation units for.
+    /// @param account The account to get attestation units for.
+    /// @param tierId The ID of the tier to get attestation units for.
     /// @return The attestation units.
-    function _getTierAttestationUnits(address _account, uint256 _tierId) internal view virtual returns (uint256) {
-        return store.tierVotingUnitsOf({hook: address(this), account: _account, tierId: _tierId});
+    function _getTierAttestationUnits(address account, uint256 tierId) internal view virtual returns (uint256) {
+        return store.tierVotingUnitsOf({hook: address(this), account: account, tierId: tierId});
     }
 
     /// @notice Mints a token in all provided tiers.
-    /// @param _amount The amount to base the mints on. All mints' price floors must fit in this amount.
-    /// @param _mintTierIds An array of tier IDs that are intended to be minted.
-    /// @param _beneficiary The address to mint for.
+    /// @param amount The amount to base the mints on. All mints' price floors must fit in this amount.
+    /// @param mintTierIds An array of tier IDs that are intended to be minted.
+    /// @param beneficiary The address to mint for.
     /// @return leftoverAmount The amount leftover after the mint.
     function _mintAll(
-        uint256 _amount,
-        uint16[] memory _mintTierIds,
-        address _beneficiary
+        uint256 amount,
+        uint16[] memory mintTierIds,
+        address beneficiary
     )
         internal
         returns (uint256 leftoverAmount)
     {
         // Keep a reference to the token ID.
-        uint256[] memory _tokenIds;
+        uint256[] memory tokenIds;
 
         // Record the mint. The returned token IDs correspond to the tiers passed in.
         // slither-disable-next-line reentrancy-benign
-        (_tokenIds, leftoverAmount) = store.recordMint({
-            amount: _amount,
-            tierIds: _mintTierIds,
+        (tokenIds, leftoverAmount) = store.recordMint({
+            amount: amount,
+            tierIds: mintTierIds,
             isOwnerMint: false // Not a manual mint
         });
 
         // Get a reference to the number of mints.
-        uint256 _mintsLength = _tokenIds.length;
+        uint256 mintsLength = tokenIds.length;
 
         // Keep a reference to the token ID being iterated on.
-        uint256 _tokenId;
+        uint256 tokenId;
 
         // Increment the paid mint cost.
-        _totalMintCost += _amount;
+        _totalMintCost += amount;
 
         // Loop through each token ID and mint.
-        for (uint256 _i; _i < _mintsLength;) {
+        for (uint256 i; i < mintsLength;) {
             // Get a reference to the tier being iterated on.
-            _tokenId = _tokenIds[_i];
+            tokenId = tokenIds[i];
 
             // Mint the tokens.
-            _mint({to: _beneficiary, tokenId: _tokenId});
+            _mint({to: beneficiary, tokenId: tokenId});
 
-            emit Mint(_tokenId, _mintTierIds[_i], _beneficiary, _amount, msg.sender);
+            emit Mint(tokenId, mintTierIds[i], beneficiary, amount, msg.sender);
 
             unchecked {
-                ++_i;
+                ++i;
             }
         }
     }
 
     /// @notice Moves delegated tier attestations from one delegate to another.
-    /// @param _from The account to transfer tier attestation units from.
-    /// @param _to The account to transfer tier attestation units to.
-    /// @param _tierId The ID of the tier for which attestation units are being transferred.
-    /// @param _amount The amount of attestation units to delegate.
-    function _moveTierDelegateAttestations(address _from, address _to, uint256 _tierId, uint256 _amount) internal {
+    /// @param from The account to transfer tier attestation units from.
+    /// @param to The account to transfer tier attestation units to.
+    /// @param tierId The ID of the tier for which attestation units are being transferred.
+    /// @param amount The amount of attestation units to delegate.
+    function _moveTierDelegateAttestations(address from, address to, uint256 tierId, uint256 amount) internal {
         // Nothing to do if moving to the same account, or no amount is being moved.
-        if (_from == _to || _amount == 0) return;
+        if (from == to || amount == 0) return;
 
         // If not moving from the zero address, update the checkpoints to subtract the amount.
-        if (_from != address(0)) {
+        if (from != address(0)) {
             // Get the current amount for the sending delegate.
-            uint208 _current = _delegateTierCheckpoints[_from][_tierId].latest();
+            uint208 current = _delegateTierCheckpoints[from][tierId].latest();
             // Set the new amount for the sending delegate.
             // uint208 is sufficient for attestation values: each tier's attestation units are bounded by the NFT
             // supply (max ~999_999_999 per tier * 128 tiers), well within uint208's ~4.1e62 range.
             // forge-lint: disable-next-line(unsafe-typecast)
-            (uint256 _oldValue, uint256 _newValue) = _delegateTierCheckpoints[_from][_tierId].push({
+            (uint256 oldValue, uint256 newValue) = _delegateTierCheckpoints[from][tierId].push({
                 // forge-lint: disable-next-line(unsafe-typecast)
                 key: uint48(block.timestamp),
                 // forge-lint: disable-next-line(unsafe-typecast)
-                value: _current - uint208(_amount)
+                value: current - uint208(amount)
             });
-            emit TierDelegateAttestationsChanged(_from, _tierId, _oldValue, _newValue, msg.sender);
+            emit TierDelegateAttestationsChanged(from, tierId, oldValue, newValue, msg.sender);
         }
 
         // If not moving to the zero address, update the checkpoints to add the amount.
-        if (_to != address(0)) {
+        if (to != address(0)) {
             // Get the current amount for the receiving delegate.
-            uint208 _current = _delegateTierCheckpoints[_to][_tierId].latest();
+            uint208 current = _delegateTierCheckpoints[to][tierId].latest();
             // Set the new amount for the receiving delegate.
             // forge-lint: disable-next-line(unsafe-typecast)
-            (uint256 _oldValue, uint256 _newValue) = _delegateTierCheckpoints[_to][_tierId].push({
+            (uint256 oldValue, uint256 newValue) = _delegateTierCheckpoints[to][tierId].push({
                 // forge-lint: disable-next-line(unsafe-typecast)
                 key: uint48(block.timestamp),
                 // forge-lint: disable-next-line(unsafe-typecast)
-                value: _current + uint208(_amount)
+                value: current + uint208(amount)
             });
-            emit TierDelegateAttestationsChanged(_to, _tierId, _oldValue, _newValue, msg.sender);
+            emit TierDelegateAttestationsChanged(to, tierId, oldValue, newValue, msg.sender);
         }
     }
 
@@ -945,92 +941,83 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
         if (!found) revert DefifaHook_NothingToMint();
 
         // Decode the metadata.
-        (address _attestationDelegate, uint16[] memory _tierIdsToMint) = abi.decode(metadata, (address, uint16[]));
+        (address attestationDelegate, uint16[] memory tierIdsToMint) = abi.decode(metadata, (address, uint16[]));
 
         // Set the beneficiary as the attestation delegate by default.
-        if (_attestationDelegate == address(0)) {
-            _attestationDelegate =
+        if (attestationDelegate == address(0)) {
+            attestationDelegate =
                 defaultAttestationDelegate != address(0) ? defaultAttestationDelegate : context.beneficiary;
         }
 
         // Make sure something is being minted.
-        if (_tierIdsToMint.length == 0) revert DefifaHook_NothingToMint();
+        if (tierIdsToMint.length == 0) revert DefifaHook_NothingToMint();
 
         // Compute attestation units per unique tier (validates ascending order, reverts on bad order).
-        (uint256[] memory _tierIds, uint256[] memory _attestationAmounts, uint256 _uniqueTierCount) = DefifaHookLib.computeAttestationUnits({
-            tierIdsToMint: _tierIdsToMint, hookStore: store, hook: address(this)
-        });
+        (uint256[] memory tierIds, uint256[] memory attestationAmounts, uint256 uniqueTierCount) =
+            DefifaHookLib.computeAttestationUnits({tierIdsToMint: tierIdsToMint, hookStore: store, hook: address(this)});
 
         // Apply attestation units for each unique tier.
-        for (uint256 _i; _i < _uniqueTierCount;) {
-            uint256 _tierId = _tierIds[_i];
+        for (uint256 i; i < uniqueTierCount;) {
+            uint256 tierId = tierIds[i];
 
             // Get a reference to the old delegate.
-            address _oldDelegate = _tierDelegation[context.beneficiary][_tierId];
+            address oldDelegate = _tierDelegation[context.beneficiary][tierId];
 
             // If there's either a new delegate or old delegate, set delegation and transfer units.
-            if (_attestationDelegate != address(0) || _oldDelegate != address(0)) {
+            if (attestationDelegate != address(0) || oldDelegate != address(0)) {
                 // Switch delegates if needed.
-                if (_attestationDelegate != address(0) && _attestationDelegate != _oldDelegate) {
-                    _delegateTier({_account: context.beneficiary, _delegatee: _attestationDelegate, _tierId: _tierId});
+                if (attestationDelegate != address(0) && attestationDelegate != oldDelegate) {
+                    _delegateTier({account: context.beneficiary, delegatee: attestationDelegate, tierId: tierId});
                 }
 
                 // Transfer the attestation units.
                 _transferTierAttestationUnits({
-                    _from: address(0), _to: context.beneficiary, _tierId: _tierId, _amount: _attestationAmounts[_i]
+                    from: address(0), to: context.beneficiary, tierId: tierId, amount: attestationAmounts[i]
                 });
             }
 
             unchecked {
-                ++_i;
+                ++i;
             }
         }
 
         // Mint tiers if they were specified.
-        uint256 _leftoverAmount =
-            _mintAll({_amount: context.amount.value, _mintTierIds: _tierIdsToMint, _beneficiary: context.beneficiary});
+        uint256 leftoverAmount =
+            _mintAll({amount: context.amount.value, mintTierIds: tierIdsToMint, beneficiary: context.beneficiary});
 
         // Make sure the buyer isn't overspending.
-        if (_leftoverAmount != 0) revert DefifaHook_Overspending();
+        if (leftoverAmount != 0) revert DefifaHook_Overspending();
     }
 
-    /// @notice Transfers, mints, or burns tier attestation units. To register a mint, `_from` should be zero. To
-    /// register a burn, `_to` should be zero. Total supply of attestation units will be adjusted with mints and burns.
-    /// @param _from The account to transfer tier attestation units from.
-    /// @param _to The account to transfer tier attestation units to.
-    /// @param _tierId The ID of the tier for which attestation units are being transferred.
-    /// @param _amount The amount of attestation units to delegate.
-    function _transferTierAttestationUnits(
-        address _from,
-        address _to,
-        uint256 _tierId,
-        uint256 _amount
-    )
-        internal
-        virtual
-    {
-        if (_from == address(0) || _to == address(0)) {
+    /// @notice Transfers, mints, or burns tier attestation units. To register a mint, `from` should be zero. To
+    /// register a burn, `to` should be zero. Total supply of attestation units will be adjusted with mints and burns.
+    /// @param from The account to transfer tier attestation units from.
+    /// @param to The account to transfer tier attestation units to.
+    /// @param tierId The ID of the tier for which attestation units are being transferred.
+    /// @param amount The amount of attestation units to delegate.
+    function _transferTierAttestationUnits(address from, address to, uint256 tierId, uint256 amount) internal virtual {
+        if (from == address(0) || to == address(0)) {
             // Get the current total for the tier.
-            uint208 _current = _totalTierCheckpoints[_tierId].latest();
+            uint208 current = _totalTierCheckpoints[tierId].latest();
 
             // If minting, add to the total tier checkpoints.
-            if (_from == address(0)) {
+            if (from == address(0)) {
                 // Casting to uint208/uint48 is safe because attestation unit amounts are bounded by NFT supply counts.
                 // forge-lint: disable-next-line(unsafe-typecast)
-                uint208 newValue = _current + uint208(_amount);
+                uint208 newValue = current + uint208(amount);
                 // forge-lint: disable-next-line(unsafe-typecast)
                 // slither-disable-next-line unused-return
-                _totalTierCheckpoints[_tierId].push({key: uint48(block.timestamp), value: newValue});
+                _totalTierCheckpoints[tierId].push({key: uint48(block.timestamp), value: newValue});
             }
 
             // If burning, subtract from the total tier checkpoints.
-            if (_to == address(0)) {
+            if (to == address(0)) {
                 // Casting to uint208/uint48 is safe because attestation unit amounts are bounded by NFT supply counts.
                 // forge-lint: disable-next-line(unsafe-typecast)
-                uint208 newValue = _current - uint208(_amount);
+                uint208 newValue = current - uint208(amount);
                 // forge-lint: disable-next-line(unsafe-typecast)
                 // slither-disable-next-line unused-return
-                _totalTierCheckpoints[_tierId].push({key: uint48(block.timestamp), value: newValue});
+                _totalTierCheckpoints[tierId].push({key: uint48(block.timestamp), value: newValue});
             }
         }
 
@@ -1040,16 +1027,16 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
         // to Carol, Carol's attestation units auto-delegate to Carol (not Bob). However, Alice's delegation
         // to Bob persists — if Alice later receives another token, her units still go to Bob. This matches
         // ERC5805Votes behavior where delegation is an account-level setting, not a token-level one.
-        address _toDelegate = _tierDelegation[_to][_tierId];
-        if (_toDelegate == address(0) && _to != address(0)) {
-            _toDelegate = _to;
-            _tierDelegation[_to][_tierId] = _to;
-            emit DelegateChanged(_to, address(0), _to);
+        address toDelegate = _tierDelegation[to][tierId];
+        if (toDelegate == address(0) && to != address(0)) {
+            toDelegate = to;
+            _tierDelegation[to][tierId] = to;
+            emit DelegateChanged(to, address(0), to);
         }
 
         // Move delegated attestations.
         _moveTierDelegateAttestations({
-            _from: _tierDelegation[_from][_tierId], _to: _toDelegate, _tierId: _tierId, _amount: _amount
+            from: _tierDelegation[from][tierId], to: toDelegate, tierId: tierId, amount: amount
         });
     }
 
@@ -1093,6 +1080,6 @@ contract DefifaHook is JB721Hook, Ownable, IDefifaHook {
         if (from == address(0)) return from;
 
         // Transfer the attestation units.
-        _transferTierAttestationUnits({_from: from, _to: to, _tierId: tier.id, _amount: tier.votingUnits});
+        _transferTierAttestationUnits({from: from, to: to, tierId: tier.id, amount: tier.votingUnits});
     }
 }