RToken Oracle

contracts/interfaces/IRTokenOracle.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: BlueOak-1.0.0
+pragma solidity 0.8.19;
+
+// RToken Oracle Interface
+interface IRTokenOracle {
+    struct CachedOracleData {
+        uint192 cachedPrice;
+        uint256 cachedAtTime;
+        uint48 cachedAtNonce;
+        uint48 cachedTradesOpen;
+        uint256 cachedTradesNonce;
+    }
+
+    // @returns rTokenPrice {D18} {UoA/tok} The price of the RToken, in UoA
+    function latestPrice() external returns (uint192 rTokenPrice, uint256 updatedAt);
+
+    // Force recalculate the price of the RToken
+    function forceUpdatePrice() external;
+}

contracts/interfaces/ITrading.sol

@@ -62,13 +62,8 @@ interface ITrading is IComponent, IRewardableComponent {
     /// @return The number of ongoing trades open
     function tradesOpen() external view returns (uint48);
 
-    /// Light wrapper around FixLib.mulDiv to support try-catch
-    function mulDiv(
-        uint192 x,
-        uint192 y,
-        uint192 z,
-        RoundingMode rounding
-    ) external pure returns (uint192);
+    /// @return The number of total trades ever opened
+    function tradesNonce() external view returns (uint256);
 }
 
 interface TestITrading is ITrading {

contracts/libraries/Fixed.sol

@@ -532,6 +532,73 @@ library FixLib {
             return uint192(shiftDelta / FIX_ONE); // {D18} = {D36} / {D18}
         }
     }
+
+    /// Divide two fixes, rounding up to FIX_MAX and down to 0
+    /// @param a Numerator
+    /// @param b Denominator
+    function safeDiv(
+        uint192 a,
+        uint192 b,
+        RoundingMode rounding
+    ) internal pure returns (uint192) {
+        if (a == 0) return 0;
+        if (b == 0) return FIX_MAX;
+
+        uint256 raw = _divrnd(FIX_ONE_256 * a, uint256(b), rounding);
+        if (raw >= FIX_MAX) return FIX_MAX;
+        return uint192(raw); // don't need _safeWrap
+    }
+
+    /// Multiplies two fixes and divide by a third
+    /// @param a First to multiply
+    /// @param b Second to multiply
+    /// @param c Denominator
+    function safeMulDiv(
+        uint192 a,
+        uint192 b,
+        uint192 c,
+        RoundingMode rounding
+    ) internal pure returns (uint192 result) {
+        if (a == 0 || b == 0) return 0;
+        if (a == FIX_MAX || b == FIX_MAX || c == 0) return FIX_MAX;
+
+        uint256 result_256;
+        unchecked {
+            (uint256 hi, uint256 lo) = fullMul(a, b);
+            if (hi >= c) return FIX_MAX;
+            uint256 mm = mulmod(a, b, c);
+            if (mm > lo) hi -= 1;
+            lo -= mm;
+            uint256 pow2 = c & (0 - c);
+
+            uint256 c_256 = uint256(c);
+            // Warning: Should not access c below this line
+
+            c_256 /= pow2;
+            lo /= pow2;
+            lo += hi * ((0 - pow2) / pow2 + 1);
+            uint256 r = 1;
+            r *= 2 - c_256 * r;
+            r *= 2 - c_256 * r;
+            r *= 2 - c_256 * r;
+            r *= 2 - c_256 * r;
+            r *= 2 - c_256 * r;
+            r *= 2 - c_256 * r;
+            r *= 2 - c_256 * r;
+            r *= 2 - c_256 * r;
+            result_256 = lo * r;
+
+            // Apply rounding
+            if (rounding == CEIL) {
+                if (mm > 0) result_256 += 1;
+            } else if (rounding == ROUND) {
+                if (mm > ((c_256 - 1) / 2)) result_256 += 1;
+            }
+        }
+
+        if (result_256 >= FIX_MAX) return FIX_MAX;
+        return uint192(result_256);
+    }
 }
 
 // ================ a couple pure-uint helpers================