Allow active period length to be set by owner (#60)

towns-protocol · May 24, 2024 · a1a2047 · a1a2047
1 parent b415698
commit a1a2047
Show file tree

Hide file tree

Showing 5 changed files with 83 additions and 72 deletions.
diff --git a/contracts/scripts/deployments/facets/DeployRewardsDistribution.s.sol b/contracts/scripts/deployments/facets/DeployRewardsDistribution.s.sol
@@ -15,8 +15,10 @@ contract DeployRewardsDistribution is Deployer, FacetHelper {
     addSelector(RewardsDistribution.getClaimableAmount.selector);
     addSelector(RewardsDistribution.claim.selector);
     addSelector(RewardsDistribution.distributeRewards.selector);
-    addSelector(RewardsDistribution.setWeeklyDistributionAmount.selector);
-    addSelector(RewardsDistribution.getWeeklyDistributionAmount.selector);
+    addSelector(RewardsDistribution.setPeriodDistributionAmount.selector);
+    addSelector(RewardsDistribution.getPeriodDistributionAmount.selector);
+    addSelector(RewardsDistribution.setActivePeriodLength.selector);
+    addSelector(RewardsDistribution.getActivePeriodLength.selector);
   }
 
   function initializer() public pure override returns (bytes4) {

diff --git a/contracts/src/base/registry/facets/distribution/IRewardsDistribution.sol b/contracts/src/base/registry/facets/distribution/IRewardsDistribution.sol
@@ -21,7 +21,11 @@ interface IRewardsDistribution is IRewardsDistributionBase {
 
   function distributeRewards(address operator) external;
 
-  function setWeeklyDistributionAmount(uint256 amount) external;
+  function setPeriodDistributionAmount(uint256 amount) external;
 
-  function getWeeklyDistributionAmount() external view returns (uint256);
+  function getPeriodDistributionAmount() external view returns (uint256);
+
+  function setActivePeriodLength(uint256 length) external;
+
+  function getActivePeriodLength() external view returns (uint256);
 }
diff --git a/contracts/src/base/registry/facets/distribution/RewardsDistribution.sol b/contracts/src/base/registry/facets/distribution/RewardsDistribution.sol
@@ -124,7 +124,7 @@ contract RewardsDistribution is
     SpaceDelegationStorage.Layout storage sd = SpaceDelegationStorage.layout();
 
     //Rewards are distributed equally amongst all active node operators
-    uint256 amountPerOperator = ds.weeklyDistributionAmount /
+    uint256 amountPerOperator = ds.periodDistributionAmount /
       totalActiveOperators;
 
     uint256 operatorClaimAmount = _calculateOperatorDistribution(
@@ -140,12 +140,20 @@ contract RewardsDistribution is
     _distributeDelegatorsRewards(sd, operator, delegatorClaimAmount);
   }
 
-  function setWeeklyDistributionAmount(uint256 amount) external onlyOwner {
-    RewardsDistributionStorage.layout().weeklyDistributionAmount = amount;
+  function setPeriodDistributionAmount(uint256 amount) external onlyOwner {
+    RewardsDistributionStorage.layout().periodDistributionAmount = amount;
   }
 
-  function getWeeklyDistributionAmount() public view returns (uint256) {
-    return RewardsDistributionStorage.layout().weeklyDistributionAmount;
+  function getPeriodDistributionAmount() public view returns (uint256) {
+    return RewardsDistributionStorage.layout().periodDistributionAmount;
+  }
+
+  function setActivePeriodLength(uint256 length) external onlyOwner {
+    RewardsDistributionStorage.layout().activePeriodLength = length;
+  }
+
+  function getActivePeriodLength() public view returns (uint256) {
+    return RewardsDistributionStorage.layout().activePeriodLength;
   }
 
   // =============================================================
@@ -349,6 +357,6 @@ contract RewardsDistribution is
   function _isActiveSinceLastCycle(
     uint256 startTime
   ) internal view returns (bool) {
-    return startTime < (block.timestamp - 7 days);
+    return startTime < (block.timestamp - getActivePeriodLength());
   }
 }
diff --git a/contracts/src/base/registry/facets/distribution/RewardsDistributionStorage.sol b/contracts/src/base/registry/facets/distribution/RewardsDistributionStorage.sol
@@ -16,7 +16,8 @@ library RewardsDistributionStorage {
     mapping(address operator => uint256) distributionByOperator;
     mapping(address delegator => uint256) distributionByDelegator;
     mapping(address operator => address[]) delegatorsByOperator;
-    uint256 weeklyDistributionAmount;
+    uint256 periodDistributionAmount;
+    uint256 activePeriodLength;
   }
 
   function layout() internal pure returns (Layout storage s) {

diff --git a/contracts/test/base/registry/RewardsDistribution.t.sol b/contracts/test/base/registry/RewardsDistribution.t.sol
@@ -52,6 +52,7 @@ contract RewardsDistributionTest is
   //example test values with expected results
   uint256 exDistributionAmount;
   uint256 exTotalSpaces;
+  uint256 exActivePeriodLength;
   uint256[] exAmountsPerUser;
   uint256[] exCommissionsPerOperator;
   uint256[] exDelegationsPerUser;
@@ -123,6 +124,7 @@ contract RewardsDistributionTest is
 
     setupOperators(tOperators);
     setupUsersAndDelegation(tUsers, tDelegations);
+    setupDistributionInformation(exDistributionAmount, exActivePeriodLength);
     verifyUsersRewards(exDistributionAmount, tUsers, tOperators, tDelegations);
 
     verifyUserRewardsAgainstExpected(
@@ -141,6 +143,7 @@ contract RewardsDistributionTest is
 
     setupOperators(tOperators);
     setupUsersAndDelegation(tUsers, tDelegations);
+    setupDistributionInformation(exDistributionAmount, exActivePeriodLength);
 
     verifyUsersRewardsClaimAction(
       exDistributionAmount,
@@ -177,7 +180,7 @@ contract RewardsDistributionTest is
       tSpaceUserDelegations,
       exDelegationsPerSpace
     );
-
+    setupDistributionInformation(exDistributionAmount, exActivePeriodLength);
     verifySpaceUsersRewards(
       exDistributionAmount,
       tSpaceUsers,
@@ -208,6 +211,7 @@ contract RewardsDistributionTest is
     setupOperators(tOperators);
     setupUsersAndDelegation(tUsers, tDelegations);
     setupMainnetDelegation(tMainnetUsers, tMainnetUserDelegations);
+    setupDistributionInformation(exDistributionAmount, exActivePeriodLength);
 
     verifyMainnetUsersRewards(
       exDistributionAmount,
@@ -264,7 +268,7 @@ contract RewardsDistributionTest is
 
     setupOperators(tOperators);
     setupUsersAndDelegation(tUsers, tDelegations);
-
+    setupDistributionInformation(distributionAmount, exActivePeriodLength);
     verifyUsersRewards(distributionAmount, tUsers, tOperators, tDelegations);
   }
 
@@ -308,6 +312,7 @@ contract RewardsDistributionTest is
     setupOperators(tOperators);
     setupUsersAndDelegation(tUsers, tDelegations);
     setupMainnetDelegation(tMainnetUsers, tMainnetUserDelegations);
+    setupDistributionInformation(distributionAmount, exActivePeriodLength);
 
     verifyMainnetUsersRewards(
       distributionAmount,
@@ -374,6 +379,7 @@ contract RewardsDistributionTest is
       tSpaceUserDelegations,
       delegationsPerSpace
     );
+    setupDistributionInformation(distributionAmount, exActivePeriodLength);
 
     verifySpaceUsersRewards(
       distributionAmount,
@@ -471,15 +477,23 @@ contract RewardsDistributionTest is
     Entity[] memory operators
   ) internal givenOperatorsHaveSetClaimAddresses(operators) {}
 
+  function setupDistributionInformation(
+    uint256 distributionAmount,
+    uint256 activePeriodLength
+  )
+    internal
+    givenPeriodDistributionAmountHasBeenSet(distributionAmount)
+    givenActivePeriodLengthHasBeenSet(exActivePeriodLength)
+    givenActivePeriodLengthHasElapsed(exActivePeriodLength)
+  {}
+
   function verifyUsersRewardsClaimAction(
     uint256 distributionAmount,
     Entity[] memory users,
     Entity[] memory operators,
     Delegation[] memory delegations
   )
     internal
-    givenWeeklyDistributionAmountHasBeenSet(distributionAmount)
-    givenOneWeekHasElapsed
     givenFundsHaveBeenDisbursed(operators, distributionAmount)
     givenTokensHaveBeenSentToDistributionContract(distributionAmount)
   {
@@ -513,12 +527,7 @@ contract RewardsDistributionTest is
     Entity[] memory users,
     Entity[] memory operators,
     Delegation[] memory delegations
-  )
-    internal
-    givenWeeklyDistributionAmountHasBeenSet(distributionAmount)
-    givenOneWeekHasElapsed
-    givenFundsHaveBeenDisbursed(operators, distributionAmount)
-  {
+  ) internal givenFundsHaveBeenDisbursed(operators, distributionAmount) {
     for (uint256 i = 0; i < users.length; i++) {
       uint256 reward = rewardsDistributionFacet.getClaimableAmount(
         users[i].addr
@@ -545,29 +554,19 @@ contract RewardsDistributionTest is
     Delegation[] memory delegations,
     Delegation[] memory spaceUserDelegations,
     uint256[] memory spaceDelegationsPerSpace
-  )
-    internal
-    givenWeeklyDistributionAmountHasBeenSet(distributionAmount)
-    givenOneWeekHasElapsed
-    givenFundsHaveBeenDisbursed(operators, distributionAmount)
-  {
+  ) internal givenFundsHaveBeenDisbursed(operators, distributionAmount) {
     for (uint256 i = 0; i < spaceUsers.length; i++) {
-      uint256 reward = rewardsDistributionFacet.getClaimableAmount(
-        spaceUsers[i].addr
-      );
-      uint256 expectedReward = _calculateExpectedSpaceUserReward(
-        spaceUsers[i].addr,
-        distributionAmount,
-        operators,
-        spaces,
-        delegations,
-        spaceUserDelegations,
-        spaceDelegationsPerSpace
-      );
-
       assertEq(
-        reward,
-        expectedReward,
+        rewardsDistributionFacet.getClaimableAmount(spaceUsers[i].addr),
+        _calculateExpectedSpaceUserReward(
+          spaceUsers[i].addr,
+          distributionAmount,
+          operators,
+          spaces,
+          delegations,
+          spaceUserDelegations,
+          spaceDelegationsPerSpace
+        ),
         "User Reward does not match expected reward"
       );
     }
@@ -579,40 +578,30 @@ contract RewardsDistributionTest is
     Entity[] memory mainnetUsers,
     Delegation[] memory delegations,
     Delegation[] memory mainnetUserDelegations
-  )
-    internal
-    givenWeeklyDistributionAmountHasBeenSet(distributionAmount)
-    givenOneWeekHasElapsed
-    givenFundsHaveBeenDisbursed(operators, distributionAmount)
-  {
+  ) internal givenFundsHaveBeenDisbursed(operators, distributionAmount) {
     for (uint256 i = 0; i < mainnetUsers.length; i++) {
       uint256 reward = rewardsDistributionFacet.getClaimableAmount(
         mainnetUsers[i].addr
       );
-      address operatorAddr;
 
       //find operator this user is delegating to:
       for (uint256 j = 0; j < mainnetUserDelegations.length; j++) {
         if (mainnetUserDelegations[j].user == mainnetUsers[i].addr) {
-          operatorAddr = mainnetUserDelegations[j].operator;
-          break;
+          assertEq(
+            reward,
+            _calculateExpectedMainnetUserReward(
+              mainnetUsers[i].addr,
+              mainnetUserDelegations[j].operator,
+              distributionAmount,
+              operators,
+              mainnetUsers,
+              delegations,
+              mainnetUserDelegations
+            ),
+            "User Reward does not match expected reward"
+          );
         }
       }
-
-      uint256 expectedReward = _calculateExpectedMainnetUserReward(
-        mainnetUsers[i].addr,
-        operatorAddr,
-        distributionAmount,
-        operators,
-        mainnetUsers,
-        delegations,
-        mainnetUserDelegations
-      );
-      assertEq(
-        reward,
-        expectedReward,
-        "User Reward does not match expected reward"
-      );
     }
   }
 
@@ -621,8 +610,8 @@ contract RewardsDistributionTest is
     Entity[] memory operators
   )
     internal
-    givenWeeklyDistributionAmountHasBeenSet(distributionAmount)
-    givenOneWeekHasElapsed
+    givenActivePeriodLengthHasElapsed(exActivePeriodLength)
+    givenPeriodDistributionAmountHasBeenSet(distributionAmount)
     givenFundsHaveBeenDisbursed(operators, distributionAmount)
   {
     for (uint256 i = 0; i < operators.length; i++) {
@@ -1008,6 +997,7 @@ contract RewardsDistributionTest is
   //used to test specific results given known input
   function initExTestValsWithResults() internal {
     exDistributionAmount = 999 * 1e18;
+    exActivePeriodLength = 14 days;
 
     exAmountsPerUser.push(1000 * 1e18);
     exAmountsPerUser.push(2000 * 1e18);
@@ -1410,14 +1400,20 @@ contract RewardsDistributionTest is
     _;
   }
 
-  modifier givenWeeklyDistributionAmountHasBeenSet(uint256 amount) {
+  modifier givenPeriodDistributionAmountHasBeenSet(uint256 amount) {
+    vm.prank(deployer);
+    rewardsDistributionFacet.setPeriodDistributionAmount(amount);
+    _;
+  }
+
+  modifier givenActivePeriodLengthHasBeenSet(uint256 length) {
     vm.prank(deployer);
-    rewardsDistributionFacet.setWeeklyDistributionAmount(amount);
+    rewardsDistributionFacet.setActivePeriodLength(length);
     _;
   }
 
-  modifier givenOneWeekHasElapsed() {
-    vm.warp(block.timestamp + 8 days);
+  modifier givenActivePeriodLengthHasElapsed(uint256 activePeriodLength) {
+    vm.warp(block.timestamp + activePeriodLength + 1 days);
     _;
   }