feat(RNG): fallback contract update

Author: unknownunknown1

contracts/src/rng/BlockhashRNG.sol

@@ -77,7 +77,7 @@ contract BlockHashRNG is IRNG {
     /// @dev Return the random number. If it has not been saved and is still computable compute it.
     /// @return randomNumber The random number or 0 if it is not ready or has not been requested.
     function receiveRandomness() external override onlyByConsumer returns (uint256 randomNumber) {
-        if (requestTimestamp == 0) return 0; // No request made
+        if (requestTimestamp == 0) return 0; // No requests were made yet.
 
         uint256 expectedTimestamp = requestTimestamp + lookaheadTime;
 
@@ -107,14 +107,14 @@ contract BlockHashRNG is IRNG {
     /// @dev Check if randomness is ready to be received.
     /// @return ready True if randomness can be received.
     function isRandomnessReady() external view returns (bool ready) {
-        if (requestTimestamp == 0) return false;
+        if (requestTimestamp == 0) return false; // No requests were made yet.
         return block.timestamp >= requestTimestamp + lookaheadTime;
     }
 
     /// @dev Get the timestamp when randomness will be ready.
     /// @return readyTimestamp The timestamp when randomness will be available.
     function getRandomnessReadyTimestamp() external view returns (uint256 readyTimestamp) {
-        if (requestTimestamp == 0) return 0;
+        if (requestTimestamp == 0) return 0; // No requests were made yet.
         return requestTimestamp + lookaheadTime;
     }
 }

contracts/src/rng/RNGWithFallback.sol

@@ -6,29 +6,21 @@ import "./IRNG.sol";
 /// @title RNG with fallback mechanism
 /// @notice Uses multiple RNG implementations with automatic fallback if default RNG does not respond passed a timeout.
 contract RNGWithFallback is IRNG {
-    uint256 public constant DEFAULT_RNG = 0;
-
     // ************************************* //
     // *             Storage               * //
     // ************************************* //
 
+    IRNG public immutable rng; // RNG address.
     address public governor; // Governor address
     address public consumer; // Consumer address
-    IRNG[] public rngs; // List of RNG implementations
     uint256 public fallbackTimeoutSeconds; // Time in seconds to wait before falling back to next RNG
     uint256 public requestTimestamp; // Timestamp of the current request
-    uint256 public currentRngIndex; // Index of the current RNG
-    bool public isRequesting; // Whether a request is in progress
 
     // ************************************* //
     // *              Events               * //
     // ************************************* //
 
-    event RNGDefaultChanged(address indexed _newDefaultRng);
-    event RNGFallback(uint256 _fromIndex, uint256 _toIndex);
-    event RNGFailure();
-    event RNGFallbackAdded(address indexed _rng);
-    event RNGFallbackRemoved(address indexed _rng);
+    event RNGFallback();
     event FallbackTimeoutChanged(uint256 _newTimeout);
 
     // ************************************* //
@@ -38,14 +30,14 @@ contract RNGWithFallback is IRNG {
     /// @param _governor Governor address
     /// @param _consumer Consumer address
     /// @param _fallbackTimeoutSeconds Time in seconds to wait before falling back to next RNG
-    /// @param _defaultRng The default RNG
-    constructor(address _governor, address _consumer, uint256 _fallbackTimeoutSeconds, IRNG _defaultRng) {
-        require(address(_defaultRng) != address(0), "Invalid default RNG");
+    /// @param _rng The RNG address (e.g. Chainlink)
+    constructor(address _governor, address _consumer, uint256 _fallbackTimeoutSeconds, IRNG _rng) {
+        require(address(_rng) != address(0), "Invalid default RNG");
 
         governor = _governor;
         consumer = _consumer;
         fallbackTimeoutSeconds = _fallbackTimeoutSeconds;
-        rngs.push(_defaultRng);
+        rng = _rng;
     }
 
     // ************************************* //
@@ -66,44 +58,25 @@ contract RNGWithFallback is IRNG {
     // *         State Modifiers          * //
     // ************************************* //
 
-    /// @dev Request a random number from the default RNG
+    /// @dev Request a random number from the RNG
     function requestRandomness() external override onlyByConsumer {
-        require(!isRequesting, "Request already in progress");
-        _requestRandomness(DEFAULT_RNG);
-    }
-
-    function _requestRandomness(uint256 _rngIndex) internal {
-        isRequesting = true;
         requestTimestamp = block.timestamp;
-        currentRngIndex = _rngIndex;
-        rngs[_rngIndex].requestRandomness();
+        rng.requestRandomness();
     }
 
     /// @dev Receive the random number with fallback logic
     /// @return randomNumber Random Number
     function receiveRandomness() external override onlyByConsumer returns (uint256 randomNumber) {
-        // Try to get random number from current RNG
-        randomNumber = rngs[currentRngIndex].receiveRandomness();
+        // Try to get random number from the RNG contract
+        randomNumber = rng.receiveRandomness();
 
         // If we got a valid number, clear the request
         if (randomNumber != 0) {
-            isRequesting = false;
             return randomNumber;
-        }
-
-        // If the timeout is exceeded, try next RNG
-        if (block.timestamp > requestTimestamp + fallbackTimeoutSeconds) {
-            uint256 nextIndex = currentRngIndex + 1;
-
-            // If we have another RNG to try, switch to it and request again
-            if (nextIndex < rngs.length) {
-                emit RNGFallback(currentRngIndex, nextIndex);
-                currentRngIndex = nextIndex;
-                _requestRandomness(nextIndex);
-            } else {
-                // No more RNGs to try
-                emit RNGFailure();
-            }
+        } else if (block.timestamp > requestTimestamp + fallbackTimeoutSeconds) {
+            // If the timeout is exceeded, try the fallback
+            randomNumber = uint256(blockhash(block.number - 1));
+            emit RNGFallback();
         }
         return randomNumber;
     }
@@ -124,61 +97,10 @@ contract RNGWithFallback is IRNG {
         consumer = _consumer;
     }
 
-    /// @dev Change the default RNG
-    /// @param _newDefaultRng Address of the new default RNG
-    function changeDefaultRng(IRNG _newDefaultRng) external onlyByGovernor {
-        require(address(_newDefaultRng) != address(0), "Invalid RNG");
-        rngs[DEFAULT_RNG] = _newDefaultRng;
-        emit RNGDefaultChanged(address(_newDefaultRng));
-
-        // Take over any pending request
-        _requestRandomness(DEFAULT_RNG);
-    }
-
-    /// @dev Add a new RNG fallback
-    /// @param _newFallbackRng Address of the new RNG fallback
-    function addRngFallback(IRNG _newFallbackRng) external onlyByGovernor {
-        require(address(_newFallbackRng) != address(0), "Invalid RNG");
-        rngs.push(_newFallbackRng);
-        emit RNGFallbackAdded(address(_newFallbackRng));
-    }
-
-    /// @dev Remove an RNG fallback
-    function removeLastRngFallback() external onlyByGovernor {
-        require(rngs.length > 1, "No fallback RNG");
-
-        // If the removed RNG is the current one, reset the fallback index
-        if (currentRngIndex > rngs.length - 2) {
-            currentRngIndex = DEFAULT_RNG;
-        }
-
-        IRNG removedRng = rngs[rngs.length - 1];
-        rngs.pop();
-        emit RNGFallbackRemoved(address(removedRng));
-    }
-
     /// @dev Change the fallback timeout
     /// @param _fallbackTimeoutSeconds New timeout in seconds
     function changeFallbackTimeout(uint256 _fallbackTimeoutSeconds) external onlyByGovernor {
         fallbackTimeoutSeconds = _fallbackTimeoutSeconds;
         emit FallbackTimeoutChanged(_fallbackTimeoutSeconds);
     }
-
-    /// @dev Emergency reset the RNG.
-    /// Useful for the governor to ensure that re-requesting a random number will not be blocked by a previous request.
-    function emergencyReset() external onlyByGovernor {
-        isRequesting = false;
-        requestTimestamp = 0;
-        currentRngIndex = DEFAULT_RNG;
-    }
-
-    // ************************************* //
-    // *           View Functions          * //
-    // ************************************* //
-
-    /// @dev Get the number of RNGs
-    /// @return Number of RNGs
-    function getRNGsCount() external view returns (uint256) {
-        return rngs.length;
-    }
 }

contracts/test/foundry/KlerosCore.t.sol

@@ -94,7 +94,7 @@ contract KlerosCoreTest is Test {
         maxDrawingTime = 24;
         hiddenVotes = false;
 
-        rngLookahead = 600;
+        rngLookahead = 30;
         rng = new BlockHashRNG(msg.sender, address(sortitionModule), rngLookahead);
 
         UUPSProxy proxyCore = new UUPSProxy(address(coreLogic), "");
@@ -1471,7 +1471,7 @@ contract KlerosCoreTest is Test {
         arbitrable.createDispute{value: feeForJuror * DEFAULT_NB_OF_JURORS}("Action");
         vm.warp(block.timestamp + minStakingTime);
         sortitionModule.passPhase(); // Generating
-        vm.roll(block.number + rngLookahead + 1);
+        vm.warp(block.timestamp + rngLookahead);
         sortitionModule.passPhase(); // Drawing phase
 
         core.draw(disputeID, DEFAULT_NB_OF_JURORS); // No one is staked so check that the empty addresses are not drawn.