Minimum Viable TWAP

packages/contracts/contracts/ActivePool.sol

@@ -11,6 +11,7 @@ import "./Dependencies/SafeERC20.sol";
 import "./Dependencies/ReentrancyGuard.sol";
 import "./Dependencies/AuthNoOwner.sol";
 import "./Dependencies/BaseMath.sol";
+import "./Dependencies/TwapWeightedObserver.sol";
 
 /**
  * @title The Active Pool holds the collateral and EBTC debt (only accounting but not EBTC tokens) for all active cdps.
@@ -19,7 +20,14 @@ import "./Dependencies/BaseMath.sol";
  * @notice (destination may vary depending on the liquidation conditions).
  * @dev ActivePool also allows ERC3156 compatible flashloan of stETH token
  */
-contract ActivePool is IActivePool, ERC3156FlashLender, ReentrancyGuard, BaseMath, AuthNoOwner {
+contract ActivePool is
+    IActivePool,
+    ERC3156FlashLender,
+    ReentrancyGuard,
+    BaseMath,
+    AuthNoOwner,
+    TwapWeightedObserver
+{
     using SafeERC20 for IERC20;
     string public constant NAME = "ActivePool";
 
@@ -49,7 +57,7 @@ contract ActivePool is IActivePool, ERC3156FlashLender, ReentrancyGuard, BaseMat
         address _collTokenAddress,
         address _collSurplusAddress,
         address _feeRecipientAddress
-    ) {
+    ) TwapWeightedObserver(0) {
         borrowerOperationsAddress = _borrowerOperationsAddress;
         cdpManagerAddress = _cdpManagerAddress;
         collateral = ICollateralToken(_collTokenAddress);
@@ -63,6 +71,8 @@ contract ActivePool is IActivePool, ERC3156FlashLender, ReentrancyGuard, BaseMat
         }
 
         emit FeeRecipientAddressChanged(_feeRecipientAddress);
+
+        require(systemDebt == 0, "ActivePool: systemDebt should be 0 for TWAP initialization");
     }
 
     // --- Getters for public variables. Required by IPool interface ---
@@ -196,6 +206,9 @@ contract ActivePool is IActivePool, ERC3156FlashLender, ReentrancyGuard, BaseMat
 
         uint256 cachedSystemDebt = systemDebt + _amount;
 
+        _setValue(uint128(cachedSystemDebt)); // @audit update TWAP global spot value and accumulator variable along with a timestamp
+        update(); // @audit update TWAP Observer accumulator and weighted average
+
         systemDebt = cachedSystemDebt;
         emit ActivePoolEBTCDebtUpdated(cachedSystemDebt);
     }
@@ -209,6 +222,9 @@ contract ActivePool is IActivePool, ERC3156FlashLender, ReentrancyGuard, BaseMat
 
         uint256 cachedSystemDebt = systemDebt - _amount;
 
+        _setValue(uint128(cachedSystemDebt)); // @audit update TWAP global spot value and accumulator variable along with a timestamp
+        update(); // @audit update TWAP Observer accumulator and weighted average
+
         systemDebt = cachedSystemDebt;
         emit ActivePoolEBTCDebtUpdated(cachedSystemDebt);
     }

packages/contracts/contracts/CdpManager.sol

@@ -348,6 +348,7 @@ contract CdpManager is CdpManagerStorage, ICdpManager, Proxy {
             totals.tcrAtStart = tcrAtStart;
             totals.systemCollSharesAtStart = systemCollSharesAtStart;
             totals.systemDebtAtStart = systemDebtAtStart;
+            totals.twapSystemDebtAtStart = EbtcMath._min(activePool.observe(), systemDebtAtStart); // @audit Return the smaller value of the two, bias towards a larger redemption scaling fee
         }
 
         _requireTCRisNotBelowMCR(totals.price, totals.tcrAtStart);
@@ -466,7 +467,7 @@ contract CdpManager is CdpManagerStorage, ICdpManager, Proxy {
         _updateBaseRateFromRedemption(
             totals.collSharesDrawn,
             totals.price,
-            totals.systemDebtAtStart
+            totals.twapSystemDebtAtStart
         );
 
         // Calculate the ETH fee

packages/contracts/contracts/Dependencies/TwapWeightedObserver.sol

@@ -0,0 +1,139 @@
+// SPDX-License Identifier: MIT
+pragma solidity 0.8.17;
+import {ITwapWeightedObserver} from "../Interfaces/ITwapWeightedObserver.sol";
+
+/// @title TwapWeightedObserver
+/// @notice Given a value, applies a time-weighted TWAP that smooths out changes over a 7 days period
+/// @dev Used to get the lowest value of total supply to prevent underpaying redemptions
+contract TwapWeightedObserver is ITwapWeightedObserver {
+    PackedData public data;
+    uint128 public valueToTrack;
+
+    constructor(uint128 initialValue) {
+        PackedData memory cachedData = PackedData({
+            observerCumuVal: initialValue,
+            accumulator: initialValue,
+            lastObserved: uint64(block.timestamp),
+            lastAccrued: uint64(block.timestamp),
+            lastObservedAverage: initialValue
+        });
+
+        valueToTrack = initialValue;
+        data = cachedData;
+    }
+
+    /// TWAP ///
+    event NewTrackValue(uint256 _oldValue, uint256 _newValue, uint256 _ts, uint256 _newAcc);
+
+    // Set to new value, sync accumulator to now with old value
+    // Changes in same block have no impact, as no time has expired
+    // Effectively we use the previous block value, and we magnify it by weight
+    function _setValue(uint128 newValue) internal {
+        uint128 _newAcc = _updateAcc(valueToTrack);
+
+        data.lastAccrued = uint64(block.timestamp);
+        emit NewTrackValue(valueToTrack, newValue, block.timestamp, _newAcc);
+        valueToTrack = newValue;
+    }
+
+    // Update the accumulator based on time passed
+    function _updateAcc(uint128 oldValue) internal returns (uint128) {
+        uint128 _newAcc = data.accumulator + oldValue * (timeToAccrue());
+        data.accumulator = _newAcc;
+        return _newAcc;
+    }
+
+    /// @notice Returns the time since the last update
+    /// @return Duration since last update
+    /// @dev Safe from overflow for tens of thousands of years
+    function timeToAccrue() public view returns (uint64) {
+        return uint64(block.timestamp) - data.lastAccrued;
+    }
+
+    /// @notice Returns the accumulator value, adjusted according to the current value and block timestamp
+    // Return the update value to now
+    function _syncToNow() internal view returns (uint128) {
+        return data.accumulator + (valueToTrack * (timeToAccrue()));
+    }
+
+    // == Getters == //
+
+    /// @notice Returns the accumulator value, adjusted according to the current value and block timestamp
+    function getLatestAccumulator() public view returns (uint128) {
+        return _syncToNow();
+    }
+
+    /// END TWAP ///
+
+    /// TWAP WEIGHTED OBSERVER ///
+
+    // Hardcoded TWAP Period of 7 days
+    uint256 public constant PERIOD = 7 days;
+
+    // Look at last
+    // Linear interpolate (or prob TWAP already does that for you)
+
+    /// @notice Returns the current value, adjusted according to the current value and block timestamp
+    function observe() external returns (uint256) {
+        // Here, we need to apply the new accumulator to skew the price in some way
+        // The weight of the skew should be proportional to the time passed
+        uint256 futureWeight = block.timestamp - data.lastObserved;
+
+        if (futureWeight == 0) {
+            return data.lastObservedAverage;
+        }
+
+        // A reference period is 7 days
+        // For each second passed after update
+        // Let's virtally sync TWAP
+        // With a weight, that is higher, the more time has passed
+        (uint128 virtualAvgValue, uint128 obsAcc) = _calcUpdatedAvg();
+
+        if (_checkUpdatePeriod()) {
+            _update(virtualAvgValue, obsAcc); // May as well update
+            // Return virtual
+            return virtualAvgValue;
+        }
+
+        uint256 weightedAvg = data.lastObservedAverage * (PERIOD - futureWeight);
+        uint256 weightedVirtual = virtualAvgValue * (futureWeight);
+
+        uint256 weightedMean = (weightedAvg + weightedVirtual) / PERIOD;
+
+        return weightedMean;
+    }
+
+    /// @dev Usual Accumulator Math, (newAcc - acc0) / (now - t0)
+    function _calcUpdatedAvg() internal view returns (uint128, uint128) {
+        uint128 latestAcc = getLatestAccumulator();
+        uint128 avgValue = (latestAcc - data.observerCumuVal) /
+            (uint64(block.timestamp) - data.lastObserved);
+        return (avgValue, latestAcc);
+    }
+
+    /// @dev Utility to update internal data
+    function _update(uint128 avgValue, uint128 obsAcc) internal {
+        data.lastObservedAverage = avgValue;
+        data.observerCumuVal = obsAcc;
+        data.lastObserved = uint64(block.timestamp);
+    }
+
+    /// @dev Should we update in observe?
+    function _checkUpdatePeriod() internal returns (bool) {
+        return block.timestamp >= (data.lastObserved + PERIOD);
+    }
+
+    /// @dev update time-weighted Observer
+    function update() public {
+        if (_checkUpdatePeriod()) {
+            (uint128 avgValue, uint128 latestAcc) = _calcUpdatedAvg();
+            _update(avgValue, latestAcc);
+        }
+    }
+
+    function getData() external view returns (PackedData memory) {
+        return data;
+    }
+
+    /// END TWAP WEIGHTED OBSERVER ///
+}

packages/contracts/contracts/Interfaces/IActivePool.sol

@@ -3,8 +3,9 @@
 pragma solidity 0.8.17;
 
 import "./IPool.sol";
+import "./ITwapWeightedObserver.sol";
 
-interface IActivePool is IPool {
+interface IActivePool is IPool, ITwapWeightedObserver {
     // --- Events ---
     event ActivePoolEBTCDebtUpdated(uint256 _EBTCDebt);
     event SystemCollSharesUpdated(uint256 _coll);

packages/contracts/contracts/Interfaces/IBaseTwapWeightedObserver.sol

@@ -0,0 +1,27 @@
+// SPDX-License Identifier: MIT
+pragma solidity 0.8.17;
+
+interface IBaseTwapWeightedObserver {
+    // NOTE: Packing manually is cheaper, but this is simpler to understand and follow
+    struct PackedData {
+        // Slot 0
+        // Seconds in a year: 3.154e+7
+        /// @dev Accumulator value recorded for TWAP Observer until last update
+        uint128 observerCumuVal; // 3.154e+7 * 80 * 100e27 = 2.5232e+38 | log_2(100e27 * 3.154e+7 * 80) = 127.568522171
+        /// @dev Accumulator for TWAP globally
+        uint128 accumulator; // 3.154e+7 * 80 * 100e27 = 2.5232e+38 | log_2(100e27 * 3.154e+7 * 80) = 127.568522171
+        // NOTE: We can further compress this slot but we will not be able to use only one (see u72 impl)
+        /// So what's the point of making the code more complex?
+
+        // Slot 1
+        /// @dev last update timestamp for TWAP Observer
+        uint64 lastObserved; // Thousands of Years, if we use relative time we can use u32 | Relative to deploy time (as immutable)
+        /// @dev last update timestamp for TWAP global track(spot) value
+        uint64 lastAccrued; // Thousands of years
+        // Expect eBTC debt to never surpass 100e27, which is 100 BILLION eBTC
+        // log_2(100e27) = 96.3359147517 | log_2(100e27 / 1e18) = 36.5412090438
+        // We could use a u64
+        /// @dev average value since last observe
+        uint128 lastObservedAverage;
+    }
+}

packages/contracts/contracts/Interfaces/ICdpManagerData.sol

@@ -201,6 +201,7 @@ interface ICdpManagerData is IRecoveryModeGracePeriod {
         uint256 decayedBaseRate;
         uint256 price;
         uint256 systemDebtAtStart;
+        uint256 twapSystemDebtAtStart;
         uint256 systemCollSharesAtStart;
         uint256 tcrAtStart;
     }

packages/contracts/contracts/Interfaces/ITwapWeightedObserver.sol

@@ -0,0 +1,17 @@
+// SPDX-License Identifier: MIT
+pragma solidity 0.8.17;
+import {IBaseTwapWeightedObserver} from "./IBaseTwapWeightedObserver.sol";
+
+interface ITwapWeightedObserver is IBaseTwapWeightedObserver {
+    function PERIOD() external view returns (uint256);
+
+    function valueToTrack() external view returns (uint128);
+
+    function timeToAccrue() external view returns (uint64);
+
+    function getLatestAccumulator() external view returns (uint128);
+
+    function observe() external returns (uint256);
+
+    function update() external;
+}

packages/contracts/contracts/TestContracts/ActivePoolTester.sol

@@ -25,14 +25,26 @@ contract ActivePoolTester is ActivePool {
     bytes4 public constant FUNC_SIG_FL_FEE = 0x72c27b62; //setFeeBps(uint256)
     bytes4 public constant FUNC_SIG_MAX_FL_FEE = 0x246d4569; //setMaxFeeBps(uint256)
 
-    function unprotectedIncreaseSystemDebt(uint256 _amount) external {
+    function unprotectedIncreaseSystemDebt(uint256 _amount) public {
         systemDebt = systemDebt + _amount;
     }
 
-    function unprotectedReceiveColl(uint256 _amount) external {
+    function unprotectedReceiveColl(uint256 _amount) public {
         systemCollShares = systemCollShares + _amount;
     }
 
+    function unprotectedIncreaseSystemDebtAndUpdate(uint256 _amount) external {
+        unprotectedIncreaseSystemDebt(_amount);
+        _setValue(uint128(systemDebt));
+        update();
+    }
+
+    function unprotectedReceiveCollAndUpdate(uint256 _amount) external {
+        unprotectedReceiveColl(_amount);
+        _setValue(uint128(systemDebt));
+        update();
+    }
+
     function unprotectedallocateSystemCollSharesToFeeRecipient(uint256 _shares) external {
         systemCollShares = systemCollShares - _shares;
         feeRecipientCollShares = feeRecipientCollShares + _shares;
@@ -41,6 +53,10 @@ contract ActivePoolTester is ActivePool {
         emit FeeRecipientClaimableCollSharesIncreased(feeRecipientCollShares, _shares);
     }
 
+    function unprotectedSetTwapTrackVal(uint256 _val) public {
+        _setValue(uint128(_val));
+    }
+
     // dummy test functions for sweepToken()
     function balanceOf(address account) external pure returns (uint256) {
         return 1234567890;

packages/contracts/contracts/TestContracts/CDPManagerTester.sol

@@ -106,7 +106,15 @@ contract CdpManagerTester is CdpManager {
         uint256 _ETHDrawn,
         uint256 _price
     ) external view returns (uint256) {
-        uint256 _totalEBTCSupply = _getSystemDebt();
+        return getUpdatedBaseRateFromRedemptionWithSystemDebt(_ETHDrawn, _price, _getSystemDebt());
+    }
+
+    function getUpdatedBaseRateFromRedemptionWithSystemDebt(
+        uint256 _ETHDrawn,
+        uint256 _price,
+        uint256 _systemDebt
+    ) public view returns (uint256) {
+        uint256 _totalEBTCSupply = EbtcMath._min(_getSystemDebt(), _systemDebt);
         uint256 decayedBaseRate = _calcDecayedBaseRate();
         uint256 redeemedEBTCFraction = (collateral.getPooledEthByShares(_ETHDrawn) * _price) /
             _totalEBTCSupply;

packages/contracts/contracts/TestContracts/Pretty.sol

@@ -54,6 +54,22 @@ library Pretty {
         return _pretty(n, decimals);
     }
 
+    function pretty(uint128 n) external pure returns (string memory) {
+        return _pretty(uint128(n), DEFAULT_DECIMALS);
+    }
+
+    function pretty(uint128 n, uint8 decimals) external pure returns (string memory) {
+        return _pretty(uint128(n), decimals);
+    }
+
+    function pretty(uint64 n) external pure returns (string memory) {
+        return _pretty(uint64(n), DEFAULT_DECIMALS);
+    }
+
+    function pretty(uint64 n, uint8 decimals) external pure returns (string memory) {
+        return _pretty(uint64(n), decimals);
+    }
+
     function pretty(int256 n) external pure returns (string memory) {
         return _prettyInt(n, DEFAULT_DECIMALS);
     }

packages/contracts/contracts/TestContracts/invariants/TargetContractSetup.sol

@@ -1,6 +1,7 @@
 pragma solidity 0.8.17;
 
 import "@crytic/properties/contracts/util/PropertiesConstants.sol";
+import "@crytic/properties/contracts/util/Hevm.sol";
 
 import "../../Interfaces/ICdpManagerData.sol";
 import "../../Dependencies/SafeMath.sol";
@@ -393,6 +394,11 @@ abstract contract TargetContractSetup is BaseStorageVariables, PropertiesConstan
         simulator = new Simulator(actorsArray, cdpManager, sortedCdps, borrowerOperations);
     }
 
+    function _syncSystemDebtTwapToSpotValue() internal {
+        hevm.warp(block.timestamp + activePool.PERIOD());
+        activePool.update();
+    }
+
     function _openWhaleCdpAndTransferEBTC() internal {
         bool success;
         Actor actor = actors[USER3]; // USER3 is the whale CDP holder