Rename rebase function parameters to better reflect their semantics

Author: ahnaguib

contracts/UFragmentsPolicy.sol

@@ -94,8 +94,8 @@ contract UFragmentsPolicy is Ownable {
 
     // DECIMALS decimal fixed point numbers.
     // Used in computation of  (Upper-Lower)/(1-(Upper/Lower)/2^(Growth*delta))) + Lower
-    int256 public rebaseFunctionLowerPercentage;
-    int256 public rebaseFunctionUpperPercentage;
+    int256 public rebaseFunctionNegativePercentageLimit;
+    int256 public rebaseFunctionPositivePercentageLimit;
     int256 public rebaseFunctionPositiveGrowth;
     int256 public rebaseFunctionNegativeGrowth;
 
@@ -167,21 +167,20 @@ contract UFragmentsPolicy is Ownable {
         orchestrator = orchestrator_;
     }
 
-
-    function setRebaseFunctionLowerPercentage(int256 rebaseFunctionLowerPercentage_)
+    function setRebaseFunctionNegativePercentageLimit(int256 rebaseFunctionNegativePercentageLimit_)
         external
         onlyOwner
     {
-        require(rebaseFunctionLowerPercentage_ <= 0);
-        rebaseFunctionLowerPercentage = rebaseFunctionLowerPercentage_;
+        require(rebaseFunctionNegativePercentageLimit_ <= 0);
+        rebaseFunctionNegativePercentageLimit = rebaseFunctionNegativePercentageLimit_;
     }
 
-    function setRebaseFunctionUpperPercentage(int256 rebaseFunctionUpperPercentage_)
+    function setRebaseFunctionPositivePercentageLimit(int256 rebaseFunctionPositivePercentageLimit_)
         external
         onlyOwner
     {
-        require(rebaseFunctionUpperPercentage_ >= 0);
-        rebaseFunctionUpperPercentage = rebaseFunctionUpperPercentage_;
+        require(rebaseFunctionPositivePercentageLimit_ >= 0);
+        rebaseFunctionPositivePercentageLimit = rebaseFunctionPositivePercentageLimit_;
     }
 
     function setRebaseFunctionPositiveGrowth(int256 rebaseFunctionPositiveGrowth_) external onlyOwner {
@@ -255,8 +254,8 @@ contract UFragmentsPolicy is Ownable {
 
         rebaseFunctionPositiveGrowth = int256(45 * (10**DECIMALS)); // Positive growth
         rebaseFunctionNegativeGrowth = int256(45 * (10**DECIMALS)); // Negative growth
-        rebaseFunctionUpperPercentage = int256(5 * (10**(DECIMALS - 2))); // 0.05
-        rebaseFunctionLowerPercentage = int256((-77) * int256(10**(DECIMALS - 3))); // -0.077
+        rebaseFunctionPositivePercentageLimit = int256(5 * (10**(DECIMALS - 2))); // 0.05
+        rebaseFunctionNegativePercentageLimit = int256((-77) * int256(10**(DECIMALS - 3))); // -0.077
 
         minRebaseTimeIntervalSec = 1 days;
         rebaseWindowOffsetSec = 7200; // 2AM UTC
@@ -346,9 +345,19 @@ contract UFragmentsPolicy is Ownable {
         // Determine growth and bounds based on positive or negative rebase
         int256 rebasePercentage;
         if (normalizedRate >= ONE) {
-            rebasePercentage = computeRebasePercentage(normalizedRate, -rebaseFunctionUpperPercentage, rebaseFunctionUpperPercentage, rebaseFunctionPositiveGrowth);
+            rebasePercentage = computeRebasePercentage(
+                normalizedRate,
+                -rebaseFunctionPositivePercentageLimit,
+                rebaseFunctionPositivePercentageLimit,
+                rebaseFunctionPositiveGrowth
+            );
         } else {
-            rebasePercentage = computeRebasePercentage(normalizedRate, rebaseFunctionLowerPercentage, -rebaseFunctionLowerPercentage, rebaseFunctionNegativeGrowth);
+            rebasePercentage = computeRebasePercentage(
+                normalizedRate,
+                rebaseFunctionNegativePercentageLimit,
+                -rebaseFunctionNegativePercentageLimit,
+                rebaseFunctionNegativeGrowth
+            );
         }
 
         return uFrags.totalSupply().toInt256Safe().mul(rebasePercentage).div(ONE);

scripts/deploy.ts

@@ -33,9 +33,10 @@ task('deploy:amplforce:testnet', 'Deploy ampleforth contract suite for testnet')
 
     // Policy
     const DEVIATION_TRESHOLD = utils.parseUnits('0.002', 18) // 0.002% (ie) 0.05/24)
-    const LOWER = utils.parseUnits('-0.005', 18)
-    const UPPER = utils.parseUnits('0.005', 18)
-    const GROWTH = utils.parseUnits('3', 18)
+    const LOWER = utils.parseUnits('-0.005', 18) // rebaseFunctionNegativePercentageLimit
+    const UPPER = utils.parseUnits('0.005', 18) // rebaseFunctionPositivePercentageLimit
+    const POSITIVE_GROWTH = utils.parseUnits('31', 18) // rebaseFunctionPositiveGrowth;
+    const NEGATIVE_GROWTH = utils.parseUnits('41', 18) // rebaseFunctionNegativeGrowth;
     const MIN_REBASE_INTERVAL = 1200 // 20 mins
     const REBASE_WINDOW_OFFSET = 0
     const REBASE_WINDOW_LEN = 2400 // 40 mins
@@ -119,7 +120,8 @@ task('deploy:amplforce:testnet', 'Deploy ampleforth contract suite for testnet')
 
     // configure parameters
     await waitFor(policy.setDeviationThreshold(DEVIATION_TRESHOLD))
-    await waitFor(policy.setRebaseFunctionGrowth(GROWTH))
+    await waitFor(policy.setRebaseFunctionPositiveGrowth(POSITIVE_GROWTH))
+    await waitFor(policy.setRebaseFunctionNegativeGrowth(NEGATIVE_GROWTH))
     await waitFor(policy.setRebaseFunctionLowerPercentage(LOWER))
     await waitFor(policy.setRebaseFunctionUpperPercentage(UPPER))
     await waitFor(

test/unit/UFragmentsPolicy.ts

@@ -426,39 +426,39 @@ describe('UFragmentsPolicy:CurveParameters', async function () {
     })
   })
 
-  describe('when rebaseFunctionLowerPercentage is more than 0', async function () {
+  describe('when rebaseFunctionNegativePercentageLimit is less than 0', async function () {
+    it('should setRebaseFunctionNegativePercentageLimit', async function () {
+      await uFragmentsPolicy
+        .connect(deployer)
+        .setRebaseFunctionNegativePercentageLimit(-1)
+      expect(await uFragmentsPolicy.rebaseFunctionNegativePercentageLimit()).to.eq(-1)
+    })
+  })
+
+  describe('when rebaseFunctionNegativePercentageLimit is more than 0', async function () {
     it('should fail', async function () {
       await expect(
         uFragmentsPolicy
           .connect(deployer)
-          .setRebaseFunctionLowerPercentage(1000),
+          .setRebaseFunctionNegativePercentageLimit(1000),
       ).to.be.reverted
     })
   })
 
-  describe('when rebaseFunctionLowerPercentage is less than 0', async function () {
-    it('should setRebaseFunctionLowerPercentage', async function () {
-      await uFragmentsPolicy
-        .connect(deployer)
-        .setRebaseFunctionLowerPercentage(-1)
-      expect(await uFragmentsPolicy.rebaseFunctionLowerPercentage()).to.eq(-1)
-    })
-  })
-
-  describe('when rebaseFunctionUpperPercentage is less than 0', async function () {
+  describe('when rebaseFunctionPositivePercentageLimit is less than 0', async function () {
     it('should fail', async function () {
       await expect(
-        uFragmentsPolicy.connect(deployer).setRebaseFunctionUpperPercentage(-1),
+        uFragmentsPolicy.connect(deployer).setRebaseFunctionPositivePercentageLimit(-1),
       ).to.be.reverted
     })
   })
 
-  describe('when rebaseFunctionUpperPercentage is more than 0', async function () {
-    it('should setRebaseFunctionUpperPercentage', async function () {
+  describe('when rebaseFunctionPositivePercentageLimit is more than 0', async function () {
+    it('should setRebaseFunctionPositivePercentageLimit', async function () {
       await uFragmentsPolicy
         .connect(deployer)
-        .setRebaseFunctionUpperPercentage(1000)
-      expect(await uFragmentsPolicy.rebaseFunctionUpperPercentage()).to.eq(1000)
+        .setRebaseFunctionPositivePercentageLimit(1000)
+      expect(await uFragmentsPolicy.rebaseFunctionPositivePercentageLimit()).to.eq(1000)
     })
   })
 })
@@ -1039,7 +1039,7 @@ describe('UFragmentsPolicy:Rebase', async function () {
         .setRebaseFunctionPositiveGrowth('25' + '000000000000000000') // Positive growth
       await uFragmentsPolicy
         .connect(deployer)
-        .setRebaseFunctionUpperPercentage('10' + '0000000000000000')
+        .setRebaseFunctionPositivePercentageLimit('10' + '0000000000000000')
       await increaseTime(60)
     })