target rate update

Author: aalavandhan

contracts/MedianOracle.sol

@@ -2,6 +2,7 @@
 pragma solidity 0.8.4;
 
 import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {MathUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol";
 import "./lib/Select.sol";
 
 interface IOracle {
@@ -15,6 +16,8 @@ interface IOracle {
  *         providers.
  */
 contract MedianOracle is OwnableUpgradeable, IOracle {
+    using MathUpgradeable for uint256;
+
     struct Report {
         uint256 timestamp;
         uint256 payload;
@@ -47,6 +50,9 @@ contract MedianOracle is OwnableUpgradeable, IOracle {
     // This is needed so that timestamp of 1 is always considered expired.
     uint256 private constant MAX_REPORT_EXPIRATION_TIME = 520 weeks;
 
+    // The final mediam value is scaled by dividing by this factor.
+    uint256 public scalar;
+
     /**
      * @notice Contract state initialization.
      *
@@ -67,6 +73,7 @@ contract MedianOracle is OwnableUpgradeable, IOracle {
         reportExpirationTimeSec = reportExpirationTimeSec_;
         reportDelaySec = reportDelaySec_;
         minimumProviders = minimumProviders_;
+        scalar = 10**18;
         __Ownable_init();
     }
 
@@ -99,6 +106,14 @@ contract MedianOracle is OwnableUpgradeable, IOracle {
         minimumProviders = minimumProviders_;
     }
 
+    /**
+     * @notice Sets the scaling factor.
+     * @param scalar_ The scaling factor.
+     */
+    function setScalar(uint256 scalar_) external onlyOwner {
+        scalar = scalar_;
+    }
+
     /**
      * @notice Pushes a report for the calling provider.
      * @param payload is expected to be 18 decimal fixed point number.
@@ -182,7 +197,7 @@ contract MedianOracle is OwnableUpgradeable, IOracle {
             return (0, false);
         }
 
-        return (Select.computeMedian(validReports, size), true);
+        return (Select.computeMedian(validReports, size).mulDiv(10**18, scalar), true);
     }
 
     /**

contracts/UFragmentsPolicy.sol

@@ -29,6 +29,7 @@ contract UFragmentsPolicy is Ownable {
     using SafeMathInt for int256;
     using UInt256Lib for uint256;
 
+    /// @notice DEPRECATED.
     event LogRebase(
         uint256 indexed epoch,
         uint256 exchangeRate,
@@ -37,16 +38,27 @@ contract UFragmentsPolicy is Ownable {
         uint256 timestampSec
     );
 
+    event Rebase(
+        uint256 indexed epoch,
+        uint256 currentRate,
+        uint256 targetRate,
+        int256 requestedSupplyAdjustment,
+        uint256 timestampSec
+    );
+
     IUFragments public uFrags;
 
-    // Provides the current CPI, as an 18 decimal fixed point number.
+    // Provides the cpi adjusted price target, as an 18 decimal fixed point number.
     IOracle public cpiOracle;
 
     // Market oracle provides the token/USD exchange rate as an 18 decimal fixed point number.
     // (eg) An oracle value of 1.5e18 it would mean 1 Ample is trading for $1.50.
     IOracle public marketOracle;
 
-    // CPI value at the time of launch, as an 18 decimal fixed point number.
+    // @notice DEPRECATED.
+    // @dev This variable is NOT being used anymore.
+    //      This used to store the CPI value at the time of launch to scale the incoming target
+    //      and infer the price target. However, now the update CPI oracle returns the price target.
     uint256 private baseCpi;
 
     // If the current exchange rate is within this fractional distance from the target, no supply
@@ -116,31 +128,29 @@ contract UFragmentsPolicy is Ownable {
 
         epoch = epoch.add(1);
 
-        uint256 cpi;
-        bool cpiValid;
-        (cpi, cpiValid) = cpiOracle.getData();
-        require(cpiValid);
-
-        uint256 targetRate = cpi.mul(10**DECIMALS).div(baseCpi);
+        uint256 targetRate;
+        bool targetRateValid;
+        (targetRate, targetRateValid) = cpiOracle.getData();
+        require(targetRateValid);
 
-        uint256 exchangeRate;
-        bool rateValid;
-        (exchangeRate, rateValid) = marketOracle.getData();
-        require(rateValid);
+        uint256 currentRate;
+        bool currentRateValid;
+        (currentRate, currentRateValid) = marketOracle.getData();
+        require(currentRateValid);
 
-        if (exchangeRate > MAX_RATE) {
-            exchangeRate = MAX_RATE;
+        if (currentRate > MAX_RATE) {
+            currentRate = MAX_RATE;
         }
 
-        int256 supplyDelta = computeSupplyDelta(exchangeRate, targetRate);
+        int256 supplyDelta = computeSupplyDelta(currentRate, targetRate);
 
         if (supplyDelta > 0 && uFrags.totalSupply().add(uint256(supplyDelta)) > MAX_SUPPLY) {
             supplyDelta = (MAX_SUPPLY.sub(uFrags.totalSupply())).toInt256Safe();
         }
 
         uint256 supplyAfterRebase = uFrags.rebase(epoch, supplyDelta);
         assert(supplyAfterRebase <= MAX_SUPPLY);
-        emit LogRebase(epoch, exchangeRate, cpi, supplyDelta, block.timestamp);
+        emit Rebase(epoch, currentRate, targetRate, supplyDelta, block.timestamp);
     }
 
     /**
@@ -241,11 +251,7 @@ contract UFragmentsPolicy is Ownable {
      *      It is called at the time of contract creation to invoke parent class initializers and
      *      initialize the contract's state variables.
      */
-    function initialize(
-        address owner_,
-        IUFragments uFrags_,
-        uint256 baseCpi_
-    ) public initializer {
+    function initialize(address owner_, IUFragments uFrags_) public initializer {
         Ownable.initialize(owner_);
 
         // deviationThreshold = 0.05e18 = 5e16
@@ -263,7 +269,6 @@ contract UFragmentsPolicy is Ownable {
         epoch = 0;
 
         uFrags = uFrags_;
-        baseCpi = baseCpi_;
     }
 
     /**

scripts/deploy.ts

@@ -64,11 +64,7 @@ task('deploy:amplforce:testnet', 'Deploy ampleforth contract suite for testnet')
     console.log('Implementation:', amplImpl)
 
     // deploy market oracle
-    const marketOracle = await deployContract(
-      hre,
-      'MedianOracle',
-      deployer,
-    )
+    const marketOracle = await deployContract(hre, 'MedianOracle', deployer)
     await marketOracle.init(
       RATE_REPORT_EXPIRATION_SEC,
       RATE_REPORT_DELAY_SEC,
@@ -77,11 +73,7 @@ task('deploy:amplforce:testnet', 'Deploy ampleforth contract suite for testnet')
     console.log('Market oracle to:', marketOracle.address)
 
     // deploy cpi oracle
-    const cpiOracle = await deployContract(
-      hre,
-      'MedianOracle',
-      deployer,
-    )
+    const cpiOracle = await deployContract(hre, 'MedianOracle', deployer)
     await cpiOracle.init(
       CPI_REPORT_EXPIRATION_SEC,
       CPI_REPORT_DELAY_SEC,

test/unit/MedianOracle.ts

@@ -218,6 +218,21 @@ describe('MedianOracle:removeProvider:accessControl', async function () {
   })
 })
 
+describe('MedianOracle:setScalar:accessControl', async function () {
+  beforeEach(async function () {
+    await setupContractsAndAccounts()
+  })
+
+  it('should be callable by owner', async function () {
+    await oracle.setScalar(ethers.utils.parseUnits('1', 18))
+  })
+
+  it('should NOT be callable by non-owner', async function () {
+    await expect(oracle.connect(A).setScalar(ethers.utils.parseUnits('1', 18)))
+      .to.be.reverted
+  })
+})
+
 describe('MedianOracle:getData', async function () {
   before(async function () {
     await setupContractsAndAccounts()
@@ -498,6 +513,35 @@ describe('MedianOracle:getData', async function () {
   })
 })
 
+describe('MedianOracle:getData', async function () {
+  before(async function () {
+    await setupContractsAndAccounts()
+    await setupCallerContract()
+
+    await oracle.setScalar(BigNumber.from('900000000000000000'))
+
+    await oracle.addProvider(await A.getAddress())
+    await oracle.addProvider(await B.getAddress())
+    await oracle.addProvider(await C.getAddress())
+    await oracle.addProvider(await D.getAddress())
+
+    await oracle.connect(D).pushReport(BigNumber.from('1000000000000000000'))
+    await oracle.connect(B).pushReport(BigNumber.from('1041000000000000000'))
+    await oracle.connect(A).pushReport(BigNumber.from('1053200000000000000'))
+    await oracle.connect(C).pushReport(BigNumber.from('2041000000000000000'))
+
+    await increaseTime(40)
+  })
+
+  describe('when a scalar is set', function () {
+    it('should scale the median', async function () {
+      await expect(callerContract.getData())
+        .to.emit(callerContract, 'ReturnValueUInt256Bool')
+        .withArgs(BigNumber.from('1163444444444444444'), true)
+    })
+  })
+})
+
 describe('MedianOracle:PurgeReports', async function () {
   before(async function () {
     await setupContractsAndAccounts()