Minimum Viable TWAP

packages/contracts/contracts/ActivePool.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity 0.8.17;
 
 import "./Interfaces/IActivePool.sol";
 import "./Interfaces/ICollSurplusPool.sol";
@@ -11,6 +11,7 @@
 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 @@
  * @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";
 
@@ -36,20 +44,20 @@
     // --- Contract setters ---
 
     /// @notice Constructor for the ActivePool contract
     /// @dev Initializes the contract with the borrowerOperationsAddress, cdpManagerAddress, collateral token address, collSurplusAddress, and feeRecipientAddress
     /// @param _borrowerOperationsAddress The address of the Borrower Operations contract
     /// @param _cdpManagerAddress The address of the Cdp Manager contract
     /// @param _collTokenAddress The address of the collateral token
     /// @param _collSurplusAddress The address of the collateral surplus pool
     /// @param _feeRecipientAddress The address of the fee recipient
 
     constructor(
         address _borrowerOperationsAddress,
         address _cdpManagerAddress,
         address _collTokenAddress,
         address _collSurplusAddress,
         address _feeRecipientAddress
-    ) {
+    ) TwapWeightedObserver(0) {
         borrowerOperationsAddress = _borrowerOperationsAddress;
         cdpManagerAddress = _cdpManagerAddress;
         collateral = ICollateralToken(_collTokenAddress);
@@ -63,12 +71,14 @@
         }
 
         emit FeeRecipientAddressChanged(_feeRecipientAddress);
+
+        require(systemDebt == 0, "ActivePool: systemDebt should be 0 for TWAP initialization");
     }
 
     // --- Getters for public variables. Required by IPool interface ---
 
     /// @notice Amount of stETH collateral shares in the contract
     /// @dev Not necessarily equal to the the contract's raw systemCollShares balance - tokens can be forcibly sent to contracts
     /// @return uint256 The amount of systemCollShares allocated to the pool
 
     function getSystemCollShares() external view override returns (uint256) {
@@ -76,7 +86,7 @@
     }
 
     /// @notice Returns the systemDebt state variable
     /// @dev The amount of EBTC debt in the pool. Like systemCollShares, this is not necessarily equal to the contract's EBTC token balance - tokens can be forcibly sent to contracts
     /// @return uint256 The amount of EBTC debt in the pool
 
     function getSystemDebt() external view override returns (uint256) {
@@ -116,11 +126,11 @@
     }
 
     /// @notice Sends stETH to a specified account, drawing from both core shares and liquidator rewards shares
     /// @notice Liquidator reward shares are not tracked via internal accounting in the active pool and are assumed to be present in expected amount as part of the intended behavior of BorowerOperations and CdpManager
     /// @dev Liquidator reward shares are added when a cdp is opened, and removed when it is closed
     /// @dev closeCdp() or liqudations result in the actor (borrower or liquidator respectively) receiving the liquidator reward shares
     /// @dev Redemptions result in the shares being sent to the coll surplus pool for claiming by the CDP owner
     /// @dev Note that funds in the coll surplus pool, just like liquidator reward shares, are not tracked as part of the system CR or coll of a CDP.
     /// @dev Requires that the caller is either BorrowerOperations or CdpManager
     /// @param _account The address of the account to send systemCollShares and the liquidator reward to
     /// @param _shares The amount of systemCollShares to send
@@ -134,7 +144,7 @@
         _requireCallerIsBOorCdpM();
 
         uint256 cachedSystemCollShares = systemCollShares;
         require(cachedSystemCollShares >= _shares, "ActivePool: Insufficient collateral shares");
         uint256 totalShares = _shares + _liquidatorRewardShares;
         unchecked {
             // Safe per the check above
@@ -196,6 +206,9 @@
 
         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 @@
 
         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