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,10 @@ import {QueryTypeStakerFactory} from "src/QueryTypeStakerFactory.sol";
 contract QueryTypeStakingPool is Ownable {
   using SafeERC20 for IERC20;
 
+  /// @notice The percentage of the stake that will decay over the full lockup + access period.
+  /// @dev Must be between 0 (no decay) and 100 (fully decayed by the end of access period).
+  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 +110,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 +156,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 +347,9 @@ contract QueryTypeStakingPool is Ownable {
     if (totalPeriod == 0) return 0;
 
     uint256 decayed = (stakeInfo.amount * elapsed) / totalPeriod;
+    // Scale by configured decay percentage
+    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
+    );
     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 {
@@ -1030,3 +1046,91 @@ contract Claim is QueryTypeStakingPoolTest {
     );
   }
 }
+
+contract DecayRate is QueryTypeStakingPoolTest {
+  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));
+
+    // Create pool with fuzzed decay rate
+    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;
+
+    // Advance time
+    vm.warp(block.timestamp + _timeElapsed);
+
+    // Claim decay
+    fuzzedPool.claim(staker);
+
+    // Verify decay behavior
+    (uint256 finalAmount,,,,,) = fuzzedPool.stakes(staker);
+
+    // All valid decay rates should result in some decay
+    assertLe(finalAmount, initialAmount, "Amount should not increase with decay");
+    assertGe(finalAmount, 0, "Amount should not go negative");
+
+    // Higher decay rates should result in more decay
+    if (_decayRate > 50) {
+      assertLt(finalAmount, initialAmount, "High decay rate should cause significant decay");
+    }
+  }
+
+  function testFuzz_DecayRateBoundaries(uint8 _decayRate) public {
+    // Test boundary conditions for decay rate
+    _decayRate = uint8(bound(_decayRate, 1, 100));
+
+    // Create pool with boundary decay rate
+    address poolAddress = factory.createStakingPool(
+      bytes32(uint256(6)), // queryType
+      address(this), // poolOwner
+      bytes32(uint256(100)), // initialEntry
+      _decayRate // boundary decay rate
+    );
+    QueryTypeStakingPool boundaryPool = QueryTypeStakingPool(poolAddress);
+
+    // Verify decay rate was set correctly
+    assertEq(boundaryPool.DECAY_RATE(), _decayRate, "Decay rate should be set correctly");
+
+    // Test that pool functions work with boundary decay rates
+    stakingToken.mint(staker, INITIAL_BALANCE);
+    vm.prank(staker);
+    stakingToken.approve(address(boundaryPool), type(uint256).max);
+
+    // Set capacity
+    boundaryPool.setStakingTokenCapacity(10_000 ether);
+
+    // Stake tokens
+    vm.prank(staker);
+    boundaryPool.stake(1000 ether);
+
+    // Verify stake was successful
+    (uint256 amount,,,,,) = boundaryPool.stakes(staker);
+    assertEq(amount, 1000 ether, "Stake should work with boundary decay rate");
+  }
+}