feat: implement DECAY_RATE

Author: thelostone-mc

src/QueryTypeStakerFactory.sol

@@ -48,18 +48,22 @@ contract QueryTypeStakerFactory is Ownable {
   /// @param _queryType The bit field representing the queries this pool will support.
   /// @param _poolOwner The address that will own the staking pool.
   /// @param _initialEntry The initial conversion table entry for the pool.
+  /// @param _decayRate The decay rate for the stake.
   /// @return _poolAddress The address of the newly created staking pool.
   /// @dev Only callable by the contract owner.
-  function createStakingPool(bytes32 _queryType, address _poolOwner, bytes32 _initialEntry)
-    external
-    returns (address _poolAddress)
-  {
+  function createStakingPool(
+    bytes32 _queryType,
+    address _poolOwner,
+    bytes32 _initialEntry,
+    uint8 _decayRate
+  ) external returns (address _poolAddress) {
     _checkOwner();
     if (queryTypePools[_queryType] != address(0)) revert QueryTypeStakerFactory__PoolExists();
 
     // Deploy new staking pool with STAKING_TOKEN address and initial conversion entry
-    QueryTypeStakingPool _newPool =
-      new QueryTypeStakingPool(_poolOwner, address(STAKING_TOKEN), address(this), _initialEntry);
+    QueryTypeStakingPool _newPool = new QueryTypeStakingPool(
+      _poolOwner, address(STAKING_TOKEN), address(this), _initialEntry, _decayRate
+    );
     _poolAddress = address(_newPool);
 
     // Store the pool address

src/QueryTypeStakingPool.sol

@@ -16,6 +16,17 @@ import {QueryTypeStakerFactory} from "src/QueryTypeStakerFactory.sol";
 contract QueryTypeStakingPool is Ownable {
   using SafeERC20 for IERC20;
 
+  /// @notice The decay rate applied to stake amounts. This rate determines what
+  /// percentage of the continuously decaying stake is lost as fees.
+  /// @dev Expressed as an integer from 0 to 100:
+  ///      - 0: No decay (0% lost as fees)
+  ///      - 100: Complete decay (100% lost as fees)
+  ///      - 50: 50% decay rate (50% lost as fees)
+  /// @dev The decay is applied continuously over time, with users losing stake at a rate
+  /// proportional to the time elapsed since their last claim. The DECAY_RATE determines
+  /// what portion of this decayed amount is lost as fees.
+  uint8 public immutable DECAY_RATE;
+
   /// @notice The duration in seconds that tokens will be locked after staking. During this period
   /// tokens cannot be withdrawn.
   uint48 public lockupPeriod = 30 days;
@@ -106,6 +117,9 @@ contract QueryTypeStakingPool is Ownable {
   /// @notice Emitted when decayed stake is claimed and forwarded to the fee recipient.
   event DecayClaimed(address indexed staker, uint256 amount, address indexed feeRecipient);
 
+  /// @notice Thrown when attempting to set a decay rate outside the allowed range.
+  error QueryTypeStakingPool__InvalidDecayRate();
+
   /// @notice Thrown when attempting to stake with an invalid lockup period.
   error QueryTypeStakingPool__LockupPeriodTooLow();
 
@@ -149,15 +163,20 @@ contract QueryTypeStakingPool is Ownable {
   /// @param _stakingToken The address of the ERC20 token that will be staked.
   /// @param _factory The address of the factory that deployed this pool.
   /// @param _initialConversionTableEntry The first entry in the conversion table history.
+  /// @param _decayRate The decay rate for the stake.
   constructor(
     address _owner,
     address _stakingToken,
     address _factory,
-    bytes32 _initialConversionTableEntry
+    bytes32 _initialConversionTableEntry,
+    uint8 _decayRate
   ) Ownable(_owner) {
     STAKING_TOKEN = IERC20(_stakingToken);
     FACTORY = _factory;
 
+    if (_decayRate > 100) revert QueryTypeStakingPool__InvalidDecayRate();
+    DECAY_RATE = _decayRate;
+
     // Initialize the conversion table with the provided entry
     conversionTableHistory.push(_initialConversionTableEntry);
     emit ConversionTableUpdated(_initialConversionTableEntry);
@@ -335,6 +354,12 @@ contract QueryTypeStakingPool is Ownable {
     if (totalPeriod == 0) return 0;
 
     uint256 decayed = (stakeInfo.amount * elapsed) / totalPeriod;
+
+    // Apply proportional fee loss based on DECAY_RATE.
+    // DECAY_RATE represents the % of the decayed amount that should be lost as fees.
+    // Example: DECAY_RATE = 80 → lose 80% of the decayed amount as fees.
+    decayed = (decayed * DECAY_RATE) / 100;
+
     if (decayed == 0) return 0;
 
     if (decayed > stakeInfo.amount) decayed = stakeInfo.amount;

test/QueryTypeStakerFactory.t.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity 0.8.26;
 
-import {Test, console2} from "forge-std/Test.sol";
+import {Test} from "forge-std/Test.sol";
 import {QueryTypeStakerFactory} from "src/QueryTypeStakerFactory.sol";
 import {QueryTypeStakingPool} from "src/QueryTypeStakingPool.sol";
 import {VmSafe} from "forge-std/Vm.sol";
@@ -20,9 +20,8 @@ contract QueryTypeStakerFactoryTest is Test {
     queryType = bytes32(uint256(1));
   }
 
-  function _createPool() internal returns (address) {
-    vm.prank(owner);
-    return factory.createStakingPool(queryType, owner, bytes32(0));
+  function _assumeSafeDecayRate(uint8 _decayRate) internal pure returns (uint8) {
+    return uint8(bound(_decayRate, 0, 100));
   }
 }
 
@@ -58,26 +57,33 @@ contract CreateStakingPool is QueryTypeStakerFactoryTest {
   function testFuzz_CreatesNewStakingPoolWithArbitraryQueryType(
     bytes32 _queryType,
     address _poolOwner,
-    bytes32 _initialEntry
+    bytes32 _initialEntry,
+    uint8 _decayRate
   ) public {
+    _decayRate = _assumeSafeDecayRate(_decayRate);
     vm.assume(_poolOwner != address(0));
     vm.prank(owner);
-    address poolAddress = factory.createStakingPool(_queryType, _poolOwner, _initialEntry);
+    address poolAddress =
+      factory.createStakingPool(_queryType, _poolOwner, _initialEntry, _decayRate);
 
     assertTrue(poolAddress != address(0));
     assertEq(factory.queryTypePools(_queryType), poolAddress);
     assertEq(QueryTypeStakingPool(poolAddress).owner(), _poolOwner);
+    assertEq(QueryTypeStakingPool(poolAddress).DECAY_RATE(), _decayRate);
   }
 
   function testFuzz_EmitsCreateQueryTypeStakingPoolEventWithArbitraryQueryType(
     bytes32 _queryType,
     address _poolOwner,
-    bytes32 _initialEntry
+    bytes32 _initialEntry,
+    uint8 _decayRate
   ) public {
+    _decayRate = _assumeSafeDecayRate(_decayRate);
     vm.assume(_poolOwner != address(0));
     vm.recordLogs();
     vm.prank(owner);
-    address poolAddress = factory.createStakingPool(_queryType, _poolOwner, _initialEntry);
+    address poolAddress =
+      factory.createStakingPool(_queryType, _poolOwner, _initialEntry, _decayRate);
 
     VmSafe.Log[] memory entries = vm.getRecordedLogs();
     assertEq(entries[2].topics[0], keccak256("CreateQueryTypeStakingPool(bytes32,address)"));
@@ -88,27 +94,31 @@ contract CreateStakingPool is QueryTypeStakerFactoryTest {
   function testFuzz_RevertIf_CallerIsNotOwner(
     address _notOwner,
     address _poolOwner,
-    bytes32 _initialEntry
+    bytes32 _initialEntry,
+    uint8 _decayRate
   ) public {
+    _decayRate = _assumeSafeDecayRate(_decayRate);
     vm.assume(_notOwner != owner && _notOwner != address(0));
     vm.assume(_poolOwner != address(0));
 
     vm.prank(_notOwner);
     vm.expectRevert(abi.encodeWithSignature("OwnableUnauthorizedAccount(address)", _notOwner));
-    factory.createStakingPool(queryType, _poolOwner, _initialEntry);
+    factory.createStakingPool(queryType, _poolOwner, _initialEntry, _decayRate);
   }
 
   function testFuzz_RevertIf_PoolAlreadyExistsWithArbitraryQueryType(
     bytes32 _queryType,
     address _poolOwner,
-    bytes32 _initialEntry
+    bytes32 _initialEntry,
+    uint8 _decayRate
   ) public {
+    _decayRate = _assumeSafeDecayRate(_decayRate);
     vm.assume(_poolOwner != address(0));
     vm.startPrank(owner);
-    factory.createStakingPool(_queryType, _poolOwner, _initialEntry);
+    factory.createStakingPool(_queryType, _poolOwner, _initialEntry, _decayRate);
 
     vm.expectRevert(QueryTypeStakerFactory.QueryTypeStakerFactory__PoolExists.selector);
-    factory.createStakingPool(_queryType, _poolOwner, _initialEntry);
+    factory.createStakingPool(_queryType, _poolOwner, _initialEntry, _decayRate);
     vm.stopPrank();
   }
 }

test/QueryTypeStakingPool.t.sol

@@ -25,9 +25,12 @@ contract QueryTypeStakingPoolTest is Test {
 
     factory.setFeeRecipient(feeRecipient);
 
-    bytes32 queryType = bytes32(uint256(1));
-    bytes32 initialEntry = bytes32(uint256(1));
-    address poolAddress = factory.createStakingPool(queryType, address(this), initialEntry);
+    address poolAddress = factory.createStakingPool(
+      bytes32(uint256(1)), // queryType
+      address(this), // poolOwner
+      bytes32(uint256(1)), // initialEntry
+      100 // decayRate (0% retained, 100% becomes fees)
+    );
     pool = QueryTypeStakingPool(poolAddress);
 
     stakingToken.mint(staker, INITIAL_BALANCE);
@@ -61,10 +64,23 @@ contract Constructor is QueryTypeStakingPoolTest {
     vm.assume(_stakingToken != address(0));
 
     QueryTypeStakingPool _newPool =
-      new QueryTypeStakingPool(_owner, _stakingToken, address(factory), _initialEntry);
+      new QueryTypeStakingPool(_owner, _stakingToken, address(factory), _initialEntry, 0);
     assertEq(address(_newPool.STAKING_TOKEN()), _stakingToken);
     assertEq(_newPool.conversionTableHistory(0), _initialEntry);
   }
+
+  function testFuzz_RevertIf_DecayRateIsInvalid(uint8 _decayRate) public {
+    _decayRate = uint8(bound(_decayRate, 101, type(uint8).max));
+
+    vm.expectRevert(QueryTypeStakingPool.QueryTypeStakingPool__InvalidDecayRate.selector);
+    new QueryTypeStakingPool(
+      address(this), // owner
+      address(stakingToken), // stakingToken
+      address(factory), // factory
+      bytes32(uint256(100)), // initialEntry
+      _decayRate
+    );
+  }
 }
 
 contract UpdateConversionTable is QueryTypeStakingPoolTest {
@@ -1029,4 +1045,67 @@ contract Claim is QueryTypeStakingPoolTest {
       pool.totalCapacityStaked(), _stakeAmount, "Total staked should remain at original amount"
     );
   }
+
+  function testFuzz_DecayRateAppliedCorrectly(
+    uint8 _decayRate,
+    uint256 _stakeAmount,
+    uint32 _timeElapsed
+  ) public {
+    // Bound parameters to reasonable ranges
+    _decayRate = uint8(bound(_decayRate, 1, 100)); // Valid decay rates only
+    _stakeAmount = bound(_stakeAmount, 100 ether, 10_000 ether);
+    _timeElapsed = uint32(bound(_timeElapsed, 1 days, 60 days));
+
+    address poolAddress = factory.createStakingPool(
+      bytes32(uint256(5)), // queryType
+      address(this), // poolOwner
+      bytes32(uint256(100)), // initialEntry
+      _decayRate // fuzzed decay rate
+    );
+    QueryTypeStakingPool fuzzedPool = QueryTypeStakingPool(poolAddress);
+
+    // Set capacity based on stake amount
+    uint256 capacity = bound(10_000 ether, _stakeAmount, _stakeAmount * 10);
+    fuzzedPool.setStakingTokenCapacity(capacity);
+
+    // Setup staker
+    stakingToken.mint(staker, INITIAL_BALANCE);
+    vm.prank(staker);
+    stakingToken.approve(address(fuzzedPool), type(uint256).max);
+
+    // Stake tokens
+    vm.prank(staker);
+    fuzzedPool.stake(_stakeAmount);
+
+    uint256 initialAmount = _stakeAmount;
+
+    // Get stake info to calculate expected decay
+    (uint256 amount,,, uint48 accessEnd, uint48 lastClaimed,) = fuzzedPool.stakes(staker);
+    uint256 totalPeriod = accessEnd - lastClaimed;
+
+    // Calculate expected decay using the same formula as the contract
+    uint256 elapsed = _timeElapsed;
+    uint256 decayed = (amount * elapsed) / totalPeriod;
+    decayed = (decayed * _decayRate) / 100;
+
+    // Cap decay at the total amount
+    if (decayed > amount) decayed = amount;
+
+    uint256 expectedFinalAmount = amount - decayed;
+
+    // Advance time
+    vm.warp(block.timestamp + _timeElapsed);
+
+    // Claim decay
+    fuzzedPool.claim(staker);
+
+    // Verify decay behavior with exact values
+    (uint256 finalAmount,,,,,) = fuzzedPool.stakes(staker);
+
+    assertEq(
+      finalAmount, expectedFinalAmount, "Final amount should match expected decay calculation"
+    );
+    assertLe(finalAmount, initialAmount, "Amount should not increase with decay");
+    assertGe(finalAmount, 0, "Amount should not go negative");
+  }
 }