## Description In adminModule/main.sol , updateCenterPriceAddress() updates the new centerPrice Address and sets the _centerPriceShift parameters. But this function doesn't take care of the last interaction timestamp of the dexVariables.(33 bits => 121-153 => last interaction time stamp). This can affect the centerPrice calculation in _getPricesAndExchangePrices() in helpers.sol ```Solidity function updateCenterPriceAddress(uint centerPriceAddress_, uint percent_, uint time_) public _check _onlyDelegateCall { if ( (centerPriceAddress_ > X30) || (percent_ == 0) || (percent_ > X20) || (time_ == 0) || (time_ > X20) ) { revert FluidDexError(ErrorTypes.DexT1Admin__ConfigOverflow); } if (centerPriceAddress_ > 0) { IFluidDexT1.ConstantViews memory c_ = IFluidDexT1(address(this)).constantsView(); address centerPrice_ = AddressCalcs.addressCalc(c_.deployerContract, centerPriceAddress_); _checkIsContract(centerPrice_); // note: if address is made 0 then as well in the last swap currentPrice is updated on storage, so code will start using that automatically dexVariables2 = (dexVariables2 & 0xFeFFFFFFFFFFFFFFFFFFFFFFFFFFC0000000FFFFFFFFFFFFFFFFFFFFFFFFFFFF) | (centerPriceAddress_ << 112) | uint(1) << 248; _centerPriceShift = block.timestamp | (percent_ << 33) | (time_ << 53); } else { dexVariables2 = (dexVariables2 & 0xFeFFFFFFFFFFFFFFFFFFFFFFFFFFC0000000FFFFFFFFFFFFFFFFFFFFFFFFFFFF); _centerPriceShift = 0; } emit LogUpdateCenterPriceAddress(centerPriceAddress_, percent_, time_); } ``` ## Proof of Concept Consider the DexAuth admin has called the updateCenterPriceAddress() to update the centerPrice address. Lets say the last interaction timestamp is 100 blocks before. updateCenterPriceAddress() updates the centerPriceAddress with the nonce, sets the new _centerPriceShift parameters. Now the timeShift used for the centerPrice calculations should be from the timestamp when updateCenterPriceAddress() was called. Consider now someone has initiated the transaction in the DEX and the _getPricesAndExchangePrices() gets the prices. In _getPricesAndExchangePrices(), if the centerPrice shift is active the the centerPrice is given by : ```Solidity centerPrice_ = _calcCenterPrice(dexVariables_, dexVariables2_); ``` The _calcCenterPrice correctly handles the centerPrice change by the updateCenterPriceAddress() properly with the check ``` fromTimeStamp_ = fromTimeStamp_ > startTimeStamp_ ? fromTimeStamp_ : startTimeStamp_; ``` ```Solidity function _calcCenterPrice(uint dexVariables_, uint dexVariables2_) internal returns (uint newCenterPrice_) { uint oldCenterPrice_ = (dexVariables_ >> 81) & X40; oldCenterPrice_ = (oldCenterPrice_ >> DEFAULT_EXPONENT_SIZE) << (oldCenterPrice_ & DEFAULT_EXPONENT_MASK); uint centerPriceShift_ = _centerPriceShift; uint startTimeStamp_ = centerPriceShift_ & X33; uint percent_ = (centerPriceShift_ >> 33) & X20; uint time_ = (centerPriceShift_ >> 53) & X20; uint fromTimeStamp_ = (dexVariables_ >> 121) & X33; fromTimeStamp_ = fromTimeStamp_ > startTimeStamp_ ? fromTimeStamp_ : startTimeStamp_; newCenterPrice_ = ICenterPrice(AddressCalcs.addressCalc(DEPLOYER_CONTRACT, ((dexVariables2_ >> 112) & X30))).centerPrice(); uint priceShift_ = (oldCenterPrice_ * percent_ * (block.timestamp - fromTimeStamp_)) / (time_ * SIX_DECIMALS); ``` The problem arises with the final calculation of the centerPrice after the _calcRangeShifting and _calcThresholdShifting calculations. Here the timeShift is calculated with the last interaction timestamp(100 blocks before) and it doesn't consider the updateCenterPriceAddress() changes. ```Solidity if (lastStoredPrice_ > (centerPrice_ + (upperRange_ - centerPrice_) * (THREE_DECIMALS - upperThreshold_) / THREE_DECIMALS)) { uint timeElapsed_ = block.timestamp - ((dexVariables_ >> 121) & X33); // price shifting towards upper range if (timeElapsed_ < shiftingTime_) { centerPrice_ = centerPrice_ + ((upperRange_ - centerPrice_) * timeElapsed_) / shiftingTime_; } else { // 100% price shifted centerPrice_ = upperRange_; } changed_ = true; } else if (lastStoredPrice_ < (centerPrice_ - (centerPrice_ - lowerRange_) * (THREE_DECIMALS - lowerThreshold_) / THREE_DECIMALS)) { uint timeElapsed_ = block.timestamp - ((dexVariables_ >> 121) & X33); // price shifting towards lower range if (timeElapsed_ < shiftingTime_) { centerPrice_ = centerPrice_ - ((centerPrice_ - lowerRange_) * timeElapsed_) / shiftingTime_; } else { // 100% price shifted centerPrice_ = lowerRange_; } changed_ = true; } ``` This can cause the centerPrice to be higher or lower than expected and can cause sudden changes in centerPrice. ## Recommendation Either update the last interaction timestamp along with updateCenterPriceAddress() or calculate the timeElapsed like how the function _calcCenterPrice() does: ``` uint centerPriceShiftTimeStamp_ = centerPriceShift_ & X33; uint lastInteractionTimestamp_ = (dexVariables_ >> 121) & X33; timeElapsed_ = block.timestamp - (lastInteractionTimestamp_ > centerPriceShiftTimeStamp_ ? lastInteractionTimestamp_ : centerPriceShiftTimeStamp_); ```

aksa

Public reviews