feat:oracle proper implementation

deploy/main/000_deploy_token.ts

@@ -11,7 +11,7 @@ const func: DeployFunction = async function ({ deployments, getNamedAccounts })
   } else {
     log('Using already deployed token at', token.address);
   }
-  
+
   log('----------------------------------------------------');
 };
 

hardhat.config.ts

@@ -221,7 +221,7 @@ const config: HardhatUserConfig = {
     runOnCompile: false,
   },
   gasReporter: {
-    enabled: true,
+    enabled: false,
     currency: 'USD',
     gasPriceApi: 'https://api.gnosisscan.io/api?module=proxy&action=eth_gasPrice', // https://docs.gnosischain.com/tools/oracles/gas-price
     token: 'GNO',

src/PriceOracle.sol

@@ -25,16 +25,15 @@ contract PriceOracle is AccessControl {
     uint64 public lastAdjustedRound;
 
     // The minimum price allowed
-    uint32 public minimumPrice = 1024;
+    uint32 public minimumPriceUpscaled = 24000 << 10; // we upscale it by 2^10
 
     // The priceBase to modulate the price
-    uint32 public priceBase = 514155;
+    uint32 public priceBase = 524288;
 
-    // The current price is the atomic unit.
-    uint32 public currentPrice = minimumPrice;
+    uint64 public currentPriceUpScaled = minimumPriceUpscaled;
 
     // Constants used to modulate the price, see below usage
-    uint32[9] public increaseRate = [514191, 514182, 514173, 514164, 514155, 514146, 514137, 514128, 514119];
+    uint32[9] public changeRate = [524324, 524315, 524306, 524297, 524288, 524279, 524270, 524261, 524252];
 
     // Role allowed to update price
     bytes32 public immutable PRICE_UPDATER_ROLE;
@@ -76,18 +75,19 @@ contract PriceOracle is AccessControl {
         if (!hasRole(DEFAULT_ADMIN_ROLE, msg.sender)) {
             revert CallerNotAdmin();
         }
-        uint32 _currentPrice = _price;
-        uint32 _minimumPrice = minimumPrice;
 
-        //enforce minimum price
-        if (_currentPrice < _minimumPrice) {
-            _currentPrice = _minimumPrice;
+        uint64 _currentPriceUpScaled = _price << 10;
+        uint64 _minimumPriceUpscaled = minimumPriceUpscaled;
+
+        // Enforce minimum price
+        if (_currentPriceUpScaled < _minimumPriceUpscaled) {
+            _currentPriceUpScaled = _minimumPriceUpscaled;
         }
-        currentPrice = _currentPrice;
+        currentPriceUpScaled = _currentPriceUpScaled;
 
         // Price in postagestamp is set at 256 so we need to upcast it
-        postageStamp.setPrice(uint256(_currentPrice));
-        emit PriceUpdate(_currentPrice);
+        postageStamp.setPrice(uint256(currentPrice()));
+        emit PriceUpdate(currentPrice());
     }
 
     function adjustPrice(uint16 redundancy) external {
@@ -99,49 +99,49 @@ contract PriceOracle is AccessControl {
             uint16 usedRedundancy = redundancy;
             uint64 currentRoundNumber = currentRound();
 
-            // price can only be adjusted once per round
+            // Price can only be adjusted once per round
             if (currentRoundNumber <= lastAdjustedRound) {
                 revert PriceAlreadyAdjusted();
             }
-            // redundancy may not be zero
+            // Redundancy may not be zero
             if (redundancy == 0) {
                 revert UnexpectedZero();
             }
 
-            // enforce maximum considered extra redundancy
+            // Enforce maximum considered extra redundancy
             uint16 maxConsideredRedundancy = targetRedundancy + maxConsideredExtraRedundancy;
             if (redundancy > maxConsideredRedundancy) {
                 usedRedundancy = maxConsideredRedundancy;
             }
 
-            uint32 _currentPrice = currentPrice;
-            uint32 _minimumPrice = minimumPrice;
+            uint64 _currentPriceUpScaled = currentPriceUpScaled;
+            uint64 _minimumPriceUpscaled = minimumPriceUpscaled;
             uint32 _priceBase = priceBase;
 
             // Set the number of rounds that were skipped
             uint64 skippedRounds = currentRoundNumber - lastAdjustedRound - 1;
 
             // We first apply the increase/decrease rate for the current round
-            uint32 ir = increaseRate[usedRedundancy];
-            _currentPrice = (ir * _currentPrice) / _priceBase;
+            uint32 _changeRate = changeRate[usedRedundancy];
+            _currentPriceUpScaled = (_changeRate * _currentPriceUpScaled) / _priceBase;
 
             // If previous rounds were skipped, use MAX price increase for the previous rounds
             if (skippedRounds > 0) {
-                ir = increaseRate[0];
+                _changeRate = changeRate[0];
                 for (uint64 i = 0; i < skippedRounds; i++) {
-                    _currentPrice = (ir * _currentPrice) / _priceBase;
+                    _currentPriceUpScaled = (_changeRate * _currentPriceUpScaled) / _priceBase;
                 }
             }
 
             // Enforce minimum price
-            if (_currentPrice < _minimumPrice) {
-                _currentPrice = _minimumPrice;
+            if (_currentPriceUpScaled < _minimumPriceUpscaled) {
+                _currentPriceUpScaled = _minimumPriceUpscaled;
             }
-            currentPrice = _currentPrice;
 
-            postageStamp.setPrice(_currentPrice);
+            currentPriceUpScaled = _currentPriceUpScaled;
             lastAdjustedRound = currentRoundNumber;
-            emit PriceUpdate(_currentPrice);
+            postageStamp.setPrice(uint256(currentPrice()));
+            emit PriceUpdate(currentPrice());
         }
     }
 
@@ -172,4 +172,20 @@ contract PriceOracle is AccessControl {
         // it results 4.4724801e+14 years to run this game
         return uint64(block.number / uint256(ROUND_LENGTH));
     }
+
+    /**
+     * @notice Return the price downscaled
+     */
+    function currentPrice() public view returns (uint32) {
+        // We downcasted to uint32 and bitshift it by 2^10
+        return uint32((currentPriceUpScaled) >> 10);
+    }
+
+    /**
+     * @notice Return the price downscaled
+     */
+    function minimumPrice() public view returns (uint32) {
+        // We downcasted to uint32 and bitshift it by 2^10
+        return uint32((minimumPriceUpscaled) >> 10);
+    }
 }

src/Redistribution.sol

@@ -137,8 +137,7 @@ contract Redistribution is AccessControl, Pausable {
     uint8 private penaltyMultiplierNonRevealed = 2;
 
     // alpha=0.097612 beta=0.0716570 k=16
-    uint256 private sampleMaxValue =
-        1284401000000000000000000000000000000000000000000000000000000000000000000;
+    uint256 private sampleMaxValue = 1284401000000000000000000000000000000000000000000000000000000000000000000;
 
     // The reveal of the winner of the last round.
     Reveal public winner;

test/PostageStamp.test.ts

@@ -50,9 +50,12 @@ const errors = {
 };
 
 describe('PostageStamp', function () {
+  let minimumPrice: number;
   describe('when deploying contract', function () {
     beforeEach(async function () {
       await deployments.fixture();
+      const priceOracle = await ethers.getContract('PriceOracle');
+      minimumPrice = await priceOracle.minimumPrice();
     });
 
     it('should have minimum bucket depth set to 16', async function () {
@@ -88,13 +91,18 @@ describe('PostageStamp', function () {
     let postageStampStamper: Contract, token: Contract, priceOracle: Contract;
     let batch: Batch;
     let batchSize: number, transferAmount: number;
-    const price0 = 1024;
+    let minimumPrice: number;
+    let price0: number;
     let setPrice0Block: number;
 
     beforeEach(async function () {
       await deployments.fixture();
       const postageStamp = await ethers.getContract('PostageStamp', deployer);
       await postageStamp.setMinimumValidityBlocks(0);
+      const priceOracle = await ethers.getContract('PriceOracle');
+      minimumPrice = await priceOracle.minimumPrice();
+      price0 = minimumPrice;
+
       const priceOracleRole = await read('PostageStamp', 'PRICE_ORACLE_ROLE');
       await execute('PostageStamp', { from: deployer }, 'grantRole', priceOracleRole, oracle);
     });
@@ -239,6 +247,7 @@ describe('PostageStamp', function () {
         );
         const batch1 = computeBatchId(stamper, nonce1);
         expect(batch1).equal(await postageStampStamper.firstBatchId());
+        const blocksElapsed2 = (await getBlockNumber()) - setPrice0Block;
 
         const nonce2 = '0x0000000000000000000000000000000000000000000000000000000000001236';
         await postageStampStamper.createBatch(
@@ -251,15 +260,17 @@ describe('PostageStamp', function () {
         );
 
         const batch2 = computeBatchId(stamper, nonce2);
-        expect(batch1).equal(await postageStampStamper.firstBatchId());
-        expect(batch2).not.equal(await postageStampStamper.firstBatchId());
+        expect(batch2).equal(await postageStampStamper.firstBatchId());
+        expect(batch1).not.equal(await postageStampStamper.firstBatchId());
+
+        const stamp = await postageStampStamper.batches(batch2);
+        const expectedNormalisedBalance2 = initialPaymentPerChunk2 + blocksElapsed2 * price0;
 
-        const stamp = await postageStampStamper.batches(batch1);
         expect(stamp[0]).to.equal(stamper);
         expect(stamp[1]).to.equal(batch.depth);
         expect(stamp[2]).to.equal(batch.bucketDepth);
         expect(stamp[3]).to.equal(batch.immutable);
-        expect(stamp[4]).to.equal(expectedNormalisedBalance1);
+        expect(stamp[4]).to.equal(expectedNormalisedBalance2);
       });
 
       it('should transfer the token', async function () {
@@ -621,15 +632,16 @@ describe('PostageStamp', function () {
       let postageStamp: Contract, token: Contract, priceOracle: Contract;
       let batch: Batch;
       let batchSize: number, transferAmount: number;
-      const price0 = 1024;
       let setPrice0Block: number, buyStampBlock: number;
+      let topupAmountPerChunk: number;
+
       const initialBatchBlocks = 10;
-      const topupAmountPerChunk = 1024;
 
       beforeEach(async function () {
         postageStamp = await ethers.getContract('PostageStamp', stamper);
         token = await ethers.getContract('TestToken', deployer);
         priceOracle = await ethers.getContract('PriceOracle', deployer);
+        topupAmountPerChunk = minimumPrice;
 
         setPrice0Block = await getBlockNumber();
         await priceOracle.setPrice(price0);
@@ -751,7 +763,6 @@ describe('PostageStamp', function () {
       let postageStamp: Contract, priceOracle: Contract;
       let batch: Batch;
       let batchSize: number, transferAmount: number;
-      const price0 = 1024;
       let setPrice0Block: number, buyStampBlock: number;
       const initialBatchBlocks = 100;
       const newDepth = 18;
@@ -852,7 +863,7 @@ describe('PostageStamp', function () {
       });
 
       it('should compute correct balance if outpayments changed since creation', async function () {
-        const newPrice = 2048;
+        const newPrice = 2 * minimumPrice;
         await priceOracle.setPrice(newPrice);
 
         const remainingBalanceNextBlock = parseInt(await postageStamp.remainingBalance(batch.id)) - newPrice * 1;
@@ -1018,7 +1029,6 @@ describe('PostageStamp', function () {
       let batch0Size: number, transferAmount0: number;
       let batch1Size: number, transferAmount1: number;
       let batch2Size: number, transferAmount2: number;
-      const price0 = 1024;
       const initialBatch0Blocks = 10;
       const initialBatch1Blocks = 10;
       const initialBatch2Blocks = 200;