Cleaned up variable names (#6)

* Change naming

Author: alexkeating

src/QueryTypeStakingPool.sol

@@ -42,7 +42,7 @@ contract QueryTypeStakingPool is Ownable {
     uint48 lockupEnd;
     uint48 accessEnd;
     uint48 lastClaimed;
-    uint256 decayed;
+    uint256 capacity;
   }
 
   /// @notice A mapping that associates staker addresses with their stake information.
@@ -57,11 +57,11 @@ contract QueryTypeStakingPool is Ownable {
   /// @notice The minimum required stake amount.
   uint256 public minimumStake;
 
-  /// @notice The total amount of tokens currently staked in the pool.
-  uint256 public totalStaked;
+  /// @notice The total amount of tokens staked in the pool before decay has been applied.
+  uint256 public totalCapacityStaked;
 
-  /// @notice The total amount of tokens currently jailed in the pool.
-  uint256 public totalJailed;
+  /// @notice The total amount of tokens currently jailed in the pool before decay has been applied.
+  uint256 public totalCapacityJailed;
 
   /// @notice Maps addresses to their blocklist status for this pool.
   mapping(address user => bool blocked) public isBlocklisted;
@@ -211,42 +211,47 @@ contract QueryTypeStakingPool is Ownable {
     if (_amount < minimumStake) revert QueryTypeStakingPool__AmountBelowMinimum();
     if (isBlocklisted[msg.sender]) revert QueryTypeStakingPool__AddressBlocklisted();
 
-    if (totalStaked - totalJailed + _amount > stakingTokenCapacity) {
+    if (totalCapacityStaked - totalCapacityJailed + _amount > stakingTokenCapacity) {
       revert QueryTypeStakingPool__CapacityExceeded();
     }
 
     // Reset lockup and access periods
-    StakeInfo memory stakeInfo = stakes[msg.sender];
-    stakeInfo.lockupEnd = uint48(block.timestamp) + lockupPeriod;
-    stakeInfo.accessEnd = stakeInfo.lockupEnd + accessPeriod;
-    totalStaked += _amount;
+    StakeInfo memory _stakeInfo = stakes[msg.sender];
+    _stakeInfo.lockupEnd = uint48(block.timestamp) + lockupPeriod;
+    _stakeInfo.accessEnd = _stakeInfo.lockupEnd + accessPeriod;
+    totalCapacityStaked += _amount;
 
-    if (stakeInfo.amount == 0) {
+    if (_stakeInfo.amount == 0) {
       // First-time stake
-      stakeInfo.amount = _amount;
-      stakeInfo.decayed = 0;
-      stakeInfo.conversionTableIndex = conversionTableHistory.length - 1;
-      stakeInfo.lastClaimed = uint48(block.timestamp);
-      stakes[msg.sender] = stakeInfo;
+      _stakeInfo.amount = _amount;
+      _stakeInfo.capacity = _amount;
+      _stakeInfo.conversionTableIndex = conversionTableHistory.length - 1;
+      _stakeInfo.lastClaimed = uint48(block.timestamp);
+      stakes[msg.sender] = _stakeInfo;
       STAKING_TOKEN.safeTransferFrom(msg.sender, address(this), _amount);
       emit Staked(
         msg.sender,
         _amount,
-        stakeInfo.conversionTableIndex,
-        stakeInfo.lockupEnd,
-        stakeInfo.accessEnd
+        _stakeInfo.conversionTableIndex,
+        _stakeInfo.lockupEnd,
+        _stakeInfo.accessEnd
       );
       return;
     }
 
-    stakeInfo.amount += _amount;
-    stakeInfo.lastClaimed = uint48(block.timestamp);
-    stakes[msg.sender] = stakeInfo;
+    _stakeInfo.amount += _amount;
+    _stakeInfo.capacity += _stakeInfo.amount;
+    _stakeInfo.lastClaimed = uint48(block.timestamp);
+    stakes[msg.sender] = _stakeInfo;
 
     STAKING_TOKEN.safeTransferFrom(msg.sender, address(this), _amount);
 
     emit Staked(
-      msg.sender, _amount, stakeInfo.conversionTableIndex, stakeInfo.lockupEnd, stakeInfo.accessEnd
+      msg.sender,
+      _amount,
+      _stakeInfo.conversionTableIndex,
+      _stakeInfo.lockupEnd,
+      _stakeInfo.accessEnd
     );
   }
 
@@ -267,11 +272,11 @@ contract QueryTypeStakingPool is Ownable {
     if (block.timestamp < userStake.lockupEnd) revert QueryTypeStakingPool__StillInLockupPeriod();
     if (_amount > userStake.amount) revert QueryTypeStakingPool__InsufficientBalance();
 
-    if (isBlocklisted[msg.sender]) totalJailed -= _amount;
-    else totalStaked -= _amount;
+    if (isBlocklisted[msg.sender]) totalCapacityJailed -= _amount;
+    else totalCapacityStaked -= _amount;
 
-    userStake.decayed = 0;
     userStake.amount -= _amount;
+    userStake.capacity = userStake.amount;
     STAKING_TOKEN.safeTransfer(msg.sender, _amount);
 
     emit Unstaked(msg.sender, _amount);
@@ -298,8 +303,8 @@ contract QueryTypeStakingPool is Ownable {
     uint256 amountToJail = userStake.amount;
 
     if (amountToJail > 0) {
-      totalJailed += amountToJail;
-      totalStaked -= amountToJail;
+      totalCapacityJailed += amountToJail;
+      totalCapacityStaked -= amountToJail;
       emit StakeJailed(_user, amountToJail);
     }
 
@@ -336,7 +341,6 @@ contract QueryTypeStakingPool is Ownable {
 
     // Apply decay and update accounting
     stakeInfo.amount -= decayed;
-    stakeInfo.decayed += decayed;
     stakeInfo.lastClaimed = uint48(block.timestamp);
 
     address feeRecipient = QueryTypeStakerFactory(FACTORY).feeRecipient();

test/QueryTypeStakingPool.t.sol

@@ -46,7 +46,7 @@ contract QueryTypeStakingPoolTest is Test {
       stakeInfo.lockupEnd,
       stakeInfo.accessEnd,
       stakeInfo.lastClaimed,
-      stakeInfo.decayed
+      stakeInfo.capacity
     ) = pool.stakes(_staker);
   }
 }
@@ -119,9 +119,9 @@ contract Stake is QueryTypeStakingPoolTest {
     assertEq(stakeInfo.lockupEnd, expectedLockupEnd);
     assertEq(stakeInfo.accessEnd, expectedAccessEnd);
     assertEq(stakeInfo.lastClaimed, block.timestamp);
-    assertEq(stakeInfo.decayed, 0);
+    assertEq(stakeInfo.capacity, _amount);
     assertEq(stakingToken.balanceOf(address(pool)), _amount);
-    assertEq(pool.totalStaked(), _amount);
+    assertEq(pool.totalCapacityStaked(), _amount);
   }
 
   function testFuzz_UpdatesExistingStakeCorrectly(
@@ -167,7 +167,9 @@ contract Stake is QueryTypeStakingPoolTest {
     );
     assertEq(stakingToken.balanceOf(address(pool)), _expectedFinal, "Pool balance incorrect");
     assertEq(
-      pool.totalStaked(), _initialAmount + _additionalAmount, "Total staked amount incorrect"
+      pool.totalCapacityStaked(),
+      _initialAmount + _additionalAmount,
+      "Total staked amount incorrect"
     );
   }
 
@@ -197,7 +199,7 @@ contract Stake is QueryTypeStakingPoolTest {
     assertEq(stakeInfo.lockupEnd, expectedLockupEnd);
     assertEq(stakeInfo.accessEnd, expectedAccessEnd);
     assertEq(stakeInfo.lastClaimed, block.timestamp);
-    assertEq(stakeInfo.decayed, 0);
+    assertEq(stakeInfo.capacity, _amount);
   }
 
   function testFuzz_EmitsStakeEvent(uint256 _amount, bytes32 _conversionEntry, uint256 _capacity)
@@ -460,9 +462,9 @@ contract Unstake is QueryTypeStakingPoolTest {
     assertEq(stakingToken.balanceOf(staker), _initialBalance + _unstakeAmt);
     QueryTypeStakingPool.StakeInfo memory remainingStakeAfter = _getStakeInfo(staker);
     assertEq(remainingStakeAfter.amount, _remainingStake - _unstakeAmt);
-    assertEq(remainingStakeAfter.decayed, 0);
+    assertEq(remainingStakeAfter.capacity, remainingStakeAfter.amount);
 
-    assertEq(pool.totalStaked(), _stakeAmount - _unstakeAmt);
+    assertEq(pool.totalCapacityStaked(), _stakeAmount - _unstakeAmt);
   }
 
   function testFuzz_UnstakeAfterMultipleStakes(
@@ -505,8 +507,8 @@ contract Unstake is QueryTypeStakingPoolTest {
     assertEq(stakingToken.balanceOf(staker), _initialBalance + _unstakeAmt);
     QueryTypeStakingPool.StakeInfo memory remainingStakeAfter = _getStakeInfo(staker);
     assertEq(remainingStakeAfter.amount, _remainingStake - _unstakeAmt);
-    assertEq(remainingStakeAfter.decayed, 0);
-    assertEq(pool.totalStaked(), totalStaked - _unstakeAmt);
+    assertEq(remainingStakeAfter.capacity, remainingStakeAfter.amount);
+    assertEq(pool.totalCapacityStaked(), totalStaked - _unstakeAmt);
   }
 
   function testFuzz_RevertIf_TokenTransferFails(
@@ -689,7 +691,7 @@ contract Unstake is QueryTypeStakingPoolTest {
     // Warp to valid unstake time
     vm.warp(block.timestamp + _timeSkip);
 
-    uint256 _initialTotalJailed = pool.totalJailed();
+    uint256 _initialTotalJailed = pool.totalCapacityJailed();
 
     // Calculate remaining stake after decay due to warp
     uint256 _remainingStake = _remainingAfterDecay(_stakeAmount, _timeSkip);
@@ -700,11 +702,11 @@ contract Unstake is QueryTypeStakingPoolTest {
     pool.unstake(_unstakeAmount);
 
     assertEq(
-      pool.totalJailed(),
+      pool.totalCapacityJailed(),
       _initialTotalJailed - _unstakeAmount,
       "Total jailed should decrease by unstake amount"
     );
-    assertEq(pool.totalStaked(), 0, "Total staked should be zero after jail scenario");
+    assertEq(pool.totalCapacityStaked(), 0, "Total staked should be zero after jail scenario");
   }
 }
 
@@ -782,8 +784,8 @@ contract Blocklist is QueryTypeStakingPoolTest {
     pool.blocklist(_user);
 
     assertTrue(pool.isBlocklisted(_user));
-    assertEq(pool.totalJailed(), _stakeAmount);
-    assertEq(pool.totalStaked(), 0);
+    assertEq(pool.totalCapacityJailed(), _stakeAmount);
+    assertEq(pool.totalCapacityStaked(), 0);
   }
 
   function testFuzz_BlocklistEmitsEvents(address _user, uint256 _stakeAmount, uint256 _capacity)
@@ -843,8 +845,8 @@ contract Blocklist is QueryTypeStakingPoolTest {
     pool.blocklist(_user);
 
     assertTrue(pool.isBlocklisted(_user));
-    assertEq(pool.totalJailed(), 0); // No tokens to jail
-    assertEq(pool.totalStaked(), 0); // No tokens staked
+    assertEq(pool.totalCapacityJailed(), 0); // No tokens to jail
+    assertEq(pool.totalCapacityStaked(), 0); // No tokens staked
   }
 
   function testFuzz_RevertIf_NotOwnerTriesToBlocklist(
@@ -919,7 +921,7 @@ contract Claim is QueryTypeStakingPoolTest {
     );
     QueryTypeStakingPool.StakeInfo memory remaining = _getStakeInfo(staker);
     assertEq(remaining.amount, _stakeAmount - _decayed, "Remaining stake incorrect");
-    assertEq(pool.totalStaked(), _stakeAmount, "Total staked incorrect");
+    assertEq(pool.totalCapacityStaked(), _stakeAmount, "Total staked incorrect");
   }
 
   function testFuzz_ClaimCallerDecayEmitsDecayClaimedEvent(
@@ -988,7 +990,7 @@ contract Claim is QueryTypeStakingPoolTest {
     vm.prank(_nonStaker);
     pool.claim(_nonStaker);
     // Should not revert and no state changes; totalStaked remains 0
-    assertEq(pool.totalStaked(), 0);
+    assertEq(pool.totalCapacityStaked(), 0);
   }
 
   function testFuzz_ClaimWhenDecayExceedsStakeAmount(uint256 _stakeAmount, uint256 _capacity)
@@ -1022,6 +1024,8 @@ contract Claim is QueryTypeStakingPoolTest {
     );
     QueryTypeStakingPool.StakeInfo memory remaining = _getStakeInfo(staker);
     assertEq(remaining.amount, 0, "Stake should be completely decayed");
-    assertEq(pool.totalStaked(), _stakeAmount, "Total staked should remain at original amount");
+    assertEq(
+      pool.totalCapacityStaked(), _stakeAmount, "Total staked should remain at original amount"
+    );
   }
 }