Adding decay with test

Author: poplexity

src/BPVoteManager.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.20;
 import "./NameConversion.sol";
 import {Ownable} from "../lib/openzeppelin-contracts/contracts/access/Ownable.sol";
 import "../lib/openzeppelin-contracts/contracts/utils/Strings.sol";
+import {console} from "../lib/forge-std/src/console.sol";
 
 /**
  * @dev Minimal interface to the STLOS Vault (ERC4626).
@@ -27,6 +28,8 @@ contract BPVoteManager is Ownable {
     // ========== State ==========
 
     ISTLOSVault public stlosVault;
+    uint256 public decayStartEpoch;
+    uint256 public decayIncreaseYearly;
 
     // Aggregated "weighted TLOS" votes per BP
     mapping(uint64 => uint256) public totalVotes;
@@ -63,6 +66,15 @@ contract BPVoteManager is Ownable {
         stlosVault = ISTLOSVault(_stlosVault);
     }
 
+    // ========== Owner Functions ==========
+    function setDecayStartEpoch(uint256 _decayStartEpoch) external onlyOwner {
+        decayStartEpoch = _decayStartEpoch;
+    }
+
+    function setDecayIncreaseYearly(uint256 _decayIncreaseYearly) external onlyOwner {
+        decayIncreaseYearly = _decayIncreaseYearly;
+    }
+
     // ========== BP Management ==========
 
     function registerBP(uint64 bpName) external onlyOwner {
@@ -212,6 +224,9 @@ contract BPVoteManager is Ownable {
         // Inverse weighting
         uint256 weightedTlos = inverseVoteWeight(tlosAmount, bps.length);
 
+        // Vote decay multiplier
+        weightedTlos = applyDecayMultiplier(weightedTlos);
+
         // Add aggregator
         for (uint256 i = 0; i < bps.length; i++) {
             totalVotes[bps[i]] += weightedTlos;
@@ -318,6 +333,48 @@ contract BPVoteManager is Ownable {
         return weighted;
     }
 
+    /**
+     * @dev Apply the decay multiplier to the weighted TLOS.
+     *      The decay multiplier follows the below code from native C++ side:
+
+      auto inverse_weighted_vote = inverse_vote_weight((double)totalStaked, (double) producers.size());
+
+      // TODO: read these from a singleton config table
+      auto decay_start_epoch = 1743739705;
+      auto decay_increase_step = 0.0000001;
+      auto decay_increase_interval_sec = 60;
+
+      auto new_vote_weight = inverse_weighted_vote;
+
+      if (decay_start_epoch > 0) {
+         auto decay_increase = (current_time_point().sec_since_epoch() - decay_start_epoch) / decay_increase_interval_sec;
+         auto decay_multiplier = 1 + (decay_increase * decay_increase_step);
+         new_vote_weight = inverse_weighted_vote * decay_multiplier;
+      }
+     */
+    function applyDecayMultiplier(uint256 weightedTlos) public view returns (uint256) {
+        if (decayStartEpoch == 0 || block.timestamp <= decayStartEpoch) {
+            return weightedTlos;
+        }
+
+        // Get current time in seconds since epoch
+        uint256 currentTime = block.timestamp;
+        uint256 secondsOfDecay = currentTime - decayStartEpoch;
+
+        // Calculate decay increase
+//        console.log("Current time:      %s", currentTime);
+//        console.log("Decay increase yearly: %s", decayIncreaseYearly);
+//        console.log("Seconds of decay: %s", secondsOfDecay);
+        // 31536000 seconds per year
+        uint256 decayMultiplier = 1e18 + ((decayIncreaseYearly * secondsOfDecay) / 31536000);
+//        console.log("Decay multiplier: %s", decayMultiplier);
+
+
+        // Apply decay multiplier
+        uint256 newVoteWeight = Math.mulDiv(weightedTlos, decayMultiplier, 1e18);
+        return newVoteWeight;
+    }
+
     /**
      * @dev Convert a uint256 to decimal string (from OpenZeppelin Strings).
      */

test/BPVoteManager.t.sol

@@ -412,4 +412,51 @@ contract CounterTest is Test {
         uint256 weight = voteManager.inverseVoteWeight(amount, bpCount);
         assertEq(weight, expectedWeight, "Weighted vote does not match expected");
     }
+
+    // ========== 8) Test applyDecayMultiplier calculation ==========
+
+    function testApplyDecayMultiplier() public {
+        uint256 yearOfDecay = 60 * 60 * 24 * 365;
+        // Use 183 because with 182 it rounds down and half of 50 becomes 24 but with 183 it rounds down to 25
+        uint256 halfYearOfDecay = 60 * 60 * 24 * 183;
+        uint256 fiftyPercentDecayRate = 500000000000000000;
+        uint256 fivePercentDecayRate =  50000000000000000;
+        checkDecay(100, 150, yearOfDecay, fiftyPercentDecayRate);
+        checkDecay(100, 125, halfYearOfDecay, fiftyPercentDecayRate);
+        checkDecay(100, 105, yearOfDecay, fivePercentDecayRate);
+
+        // Large number tests (10 million * 1e18 = 10 million tokens)
+        uint256 largeInitial = 10_000_000 * 1e18;
+        checkDecay(largeInitial, (largeInitial * 150) / 100, yearOfDecay, fiftyPercentDecayRate); // 50% increase
+
+        uint256 expected = calculateExpected(largeInitial, halfYearOfDecay, fiftyPercentDecayRate);
+        checkDecay(largeInitial, expected, halfYearOfDecay, fiftyPercentDecayRate);
+
+        checkDecay(largeInitial, (largeInitial * 105) / 100, yearOfDecay, fivePercentDecayRate); // 5% increase
+    }
+
+    function calculateExpected(
+        uint256 amount,
+        uint256 secondsOfDecay,
+        uint256 decayIncreaseYearly
+    ) internal pure returns (uint256) {
+        // Compute: decayMultiplier = 1e18 + ((decayIncreaseYearly * secondsOfDecay) / SECONDS_PER_YEAR)
+        uint256 decayMultiplier = 1e18 + ((decayIncreaseYearly * secondsOfDecay) / 31536000);
+        // Apply: (amount * decayMultiplier) / 1e18
+        return (amount * decayMultiplier) / 1e18;
+    }
+
+    function checkDecay(uint256 amount, uint256 expectedWeight, uint256 secondsOfDecay, uint256 decayIncreaseYearly) internal {
+        // This can be anything, just as long as we can go back a year
+        //   (i.e. it can't be 0 which is the default if you don't set it)
+        vm.warp(1743800000);
+//        console.log("Block timestamp: %s", vm.getBlockTimestamp());
+        voteManager.setDecayStartEpoch(vm.getBlockTimestamp() - secondsOfDecay);
+        //decayIncreaseYearly = 0.5 × 1e18 = 500000000000000000
+        voteManager.setDecayIncreaseYearly(decayIncreaseYearly);
+//        console.log("Decay start epoch: %s", voteManager.decayStartEpoch());
+//        console.log("Decay increase yearly: %s", voteManager.decayIncreaseYearly());
+        uint256 weight = voteManager.applyDecayMultiplier(amount);
+        assertEq(weight, expectedWeight, "applyDecayMultiplier does not match expected");
+    }
 }

test/test_native_function.cpp

@@ -0,0 +1,56 @@
+#include <cstdint>
+#include <cstdio>
+#include <cmath>
+
+// Updated implementation for C++ without Solidity scaling
+double apply_decay_multiplier(double weighted_vote, uint32_t sec_since_epoch, uint64_t decay_start_epoch, uint64_t decay_increase_yearly) {
+    if (decay_start_epoch == 0 || sec_since_epoch <= decay_start_epoch) {
+        return weighted_vote;
+    }
+
+    const uint32_t SECONDS_PER_YEAR = 31536000;
+    uint64_t seconds_of_decay = sec_since_epoch - decay_start_epoch;
+
+    // decay_increase_yearly is now directly a percentage (e.g., 50 for 50%)
+    double decay_multiplier = 1.0 + (static_cast<double>(decay_increase_yearly) / 100.0) * (static_cast<double>(seconds_of_decay) / SECONDS_PER_YEAR);
+
+    double new_vote_weight = weighted_vote * decay_multiplier;
+
+    return new_vote_weight;
+}
+
+// Basic test function
+void checkDecay(double initialVote, double expectedVote, uint32_t decaySeconds, uint64_t decayIncreaseYearly) {
+    uint64_t decayStartEpoch = 1000000000; // arbitrary epoch
+    uint32_t testEpoch = decayStartEpoch + decaySeconds;
+    double result = apply_decay_multiplier(initialVote, testEpoch, decayStartEpoch, decayIncreaseYearly);
+
+    printf("Initial vote: %.2f, Expected vote: %.2f, Actual vote: %.2f\n", initialVote, expectedVote, result);
+
+    if (fabs(result - expectedVote) < 0.1) {
+        printf("Test PASSED\n\n");
+    } else {
+        printf("Test FAILED\n\n");
+    }
+}
+
+int main() {
+    uint32_t yearOfDecay = 60 * 60 * 24 * 365;
+    uint32_t halfYearOfDecay = yearOfDecay / 2;
+
+    checkDecay(100, 150, yearOfDecay, 50);
+    checkDecay(100, 125, halfYearOfDecay, 50);
+    checkDecay(100, 105, yearOfDecay, 5);
+
+    // Large value test (10 million * 10,000 for 4 decimal precision)
+    double largeInitial = 10000000.0 * 10000.0;
+    double expectedLargeFullYear = largeInitial * 1.5; // 50% increase
+    double expectedLargeHalfYear = largeInitial * 1.25; // 25% increase
+    double expectedLargeFullYearFivePercent = largeInitial * 1.05; // 5% increase`
+
+    checkDecay(largeInitial, expectedLargeFullYear, yearOfDecay, 50);
+    checkDecay(largeInitial, expectedLargeHalfYear, halfYearOfDecay, 50);
+    checkDecay(largeInitial, expectedLargeFullYearFivePercent, yearOfDecay, 5);
+
+    return 0;
+}