feat: migrate tests for wega random number controller

contracts/IWegaRandomizerController.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+import './events/IWegaRandomizerControllerEvents.sol';
+
+interface IWegaRandomizerController is IWegaRandomizerControllerEvents {
+ /**
+ * @notice this method calculates rollValue
+ * @param denominator the posibilities that can be rolled
+ */
+ function generate(uint256 denominator) external returns(uint256);
+
+ /**
+ * @notice this method calculates rollValue
+ * @param newRandomizer address of the new randomizer
+ */
+ function setRandomizer(address newRandomizer) external;
+
+ /**
+ * @notice seeds the randomizer with new random number values
+ * @param randomNumbers randomnumbers to add
+ */
+ function seedRandomizer(uint256[] memory randomNumbers) external;
+
+ /**
+ * @notice increments the user nonce on the randomizer
+ */
+ function incrementControllerNonce() external;
+}

contracts/WegaGameController.sol

@@ -12,7 +12,7 @@ import "./roles/WegaProtocolAdminRole.sol";
 import "./events/IWegaGameControllerEvents.sol";
 import "./events/IERC20EscrowEvents.sol";
 import "./IWegaGameController.sol";
-import "./IWegaRandomNumberController.sol";
+import "./IWegaRandomizerController.sol";
 import "./utils/Arrays.sol";
 import './errors/WegaGameControllerErrors.sol';
 import "./utils/Strings.sol";
@@ -27,7 +27,6 @@ import "./games/IWega.sol";
   * that require two people for play 
   * @dev note this is draft contract not meant to be used in production
 */
-
 contract WegaGameController is 
   IWegaGameController, 
   IWegaGameControllerEvents,
@@ -42,7 +41,7 @@ contract WegaGameController is
   using Arrays for uint256[];
 
   IWegaERC20Escrow public erc20Escrow;
-  IWegaRandomNumberController public randomizer;
+  IWegaRandomizerController public randomizerController;
 
   mapping(bytes32 => IWega.Wega) private _games;
   mapping(uint256 => address) _registeredGames;
@@ -51,13 +50,13 @@ contract WegaGameController is
 
   function initialize(
     address erc20EscrowAddress, 
-    address randomNumberController,
+    address randomizerController_,
     GameSettings[] memory gameSettings
   ) initializer public {
     __WegaController_init(erc20EscrowAddress, gameSettings);
     __WegaProtocolAdminRole_init();
     __UUPSUpgradeable_init();
-    randomizer = IWegaRandomNumberController(randomNumberController);
+    randomizerController = IWegaRandomizerController(randomizerController_);
   }
 
   function __WegaController_init(
@@ -264,6 +263,6 @@ contract WegaGameController is
   function _authorizeUpgrade(address newImplementation) internal onlyOwner override {}
 
   function _seedRandomizerBeforeCreateOrDeposit(uint256[] memory randomNumbers) internal {
-    randomizer.addRandomNumbers(randomNumbers);
+    randomizerController.seedRandomizer(randomNumbers);
   }
 }

contracts/WegaRandomNumberController.sol → contracts/WegaRandomizerController.sol

@@ -14,18 +14,26 @@ import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
 import "@openzeppelin/contracts/utils/math/Math.sol";
 
-import "./IWegaRandomNumberController.sol";
+import "./IWegaRandomizerController.sol";
+import "./errors/AccessControlErrors.sol";
 import "./roles/WegaProtocolAdminRole.sol";
+import "./randomizer/IWegaRandomizer.sol";
+import "./randomizer/WegaRandomizer.sol";
 
-contract WegaRandomNumberController is IWegaRandomNumberController, WegaProtocolAdminRole, UUPSUpgradeable {
+contract WegaRandomizerController is AccessControlErrors, WegaProtocolAdminRole, UUPSUpgradeable, IWegaRandomizerController {
 
   using EnumerableMapUpgradeable for EnumerableMapUpgradeable.UintToUintMap;
   using Math for uint256;
   using CountersUpgradeable for CountersUpgradeable.Counter;
 
+  address public RANDOMIZER; 
   bytes32 public GAME_CONTROLLER_ROLE;
-  CountersUpgradeable.Counter _nonce;
-  EnumerableMapUpgradeable.UintToUintMap private _randomNumbers;
+  bytes32 public GAME_ROLE;
+
+  modifier onlyGameOrGameController {
+    require(hasRole(GAME_CONTROLLER_ROLE, _msgSender()) || hasRole(GAME_ROLE, _msgSender()), CALLER_NOT_ALLOWED);
+    _;
+  }
 
   function initialize(uint256[] memory randomNumbers) initializer public {
     __UUPSUpgradeable_init();
@@ -35,52 +43,52 @@ contract WegaRandomNumberController is IWegaRandomNumberController, WegaProtocol
 
   function __WegaRandomNumberController_init(uint256[] memory randomNumbers) internal onlyInitializing {
     GAME_CONTROLLER_ROLE = keccak256('GAME_CONTROLLER_ROLE');
+    GAME_ROLE = keccak256('GAME_ROLE');
     _setRoleAdmin(GAME_CONTROLLER_ROLE, WEGA_PROTOCOL_ADMIN_ROLE);
+    _setRoleAdmin(GAME_ROLE, WEGA_PROTOCOL_ADMIN_ROLE);
     __WegaRandomNumberController_init_unchained(randomNumbers);
   } 
 
   function __WegaRandomNumberController_init_unchained(uint256[] memory randomNumbers) internal onlyInitializing {
-   _seedRandomizer(randomNumbers);
-   _nonce.increment();
+   _spawnRandomizer(randomNumbers);
   } 
 
-  function generate(uint256 denominator, uint256 nonce) public view override returns(uint256) {
-    uint256 randomNumber = _retrieveRandomNumber(nonce);
+  function generate(uint256 denominator) public view override returns(uint256) {
+    uint256 randomNumber = getRandomizer().retrieve();
     uint256 result = (randomNumber % denominator) + 1;
     return result;
   }
 
-  function _retrieveRandomNumber(uint256 nonce) internal view returns (uint256){
-    uint256 count = _randomNumbers.length();
-    uint256 randomIndex = uint256(keccak256(abi.encodePacked(
-      tx.origin,
-      blockhash(block.number - nonce),
-      block.timestamp,
-      block.prevrandao,
-      nonce
-    ))) % count;
-    return _randomNumbers.get(randomIndex); 
+  function seedRandomizer(uint256[] memory randomNumbers) public override onlyRole(GAME_CONTROLLER_ROLE) {
+    getRandomizer().seed(randomNumbers);
   }
-
-  function randomNumbersCount() public view override returns (uint256) {
-    return _randomNumbers.length();
+  
+  function incrementControllerNonce() public override onlyGameOrGameController {
+    getRandomizer().useOwnerNonce();
   }
 
-  function addRandomNumbers(uint256[] memory randomNumbers) public override onlyRole(GAME_CONTROLLER_ROLE) {
-    _seedRandomizer(randomNumbers);
-  }
+  function _authorizeUpgrade(address newImplementation) internal onlyOwner override {}
 
-  function seedRandomizer(uint256[] memory randomNumbers) public override onlyWegaProtocolAdmin {
-    _seedRandomizer(randomNumbers);
+  function getRandomizer() public view returns (IWegaRandomizer randomizer){
+    randomizer = IWegaRandomizer(RANDOMIZER);
   }
+
+  function setRandomizer(address randomizer) public onlyWegaProtocolAdmin {
+    _setRandomizer(randomizer);
+  } 
 
-  function _seedRandomizer(uint256[] memory randomNumbers) internal {
-    for(uint256 i = _randomNumbers.length(); i < randomNumbers.length;i++) {
-      if(!_randomNumbers.contains(randomNumbers[i])) {
-        _randomNumbers.set(i, randomNumbers[i]);
-      }
-    }
+  function _setRandomizer(address randomizer) internal {
+    RANDOMIZER = randomizer;
+    emit RandomizerSet(RANDOMIZER);
   }
 
-  function _authorizeUpgrade(address newImplementation) internal onlyOwner override {}
+  function spawnRandomizer(uint256[] memory randomNumbers) public onlyWegaProtocolAdmin {
+    _spawnRandomizer(randomNumbers);
+  }
+
+  function _spawnRandomizer(uint256[] memory randomNumbers) internal {
+    WegaRandomizer randomizer = new WegaRandomizer(randomNumbers);
+    RANDOMIZER = address(randomizer);
+    emit RandomizerSet(RANDOMIZER);
+  }
 }

contracts/events/IWegaRandomizerControllerEvents.sol

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.14;
+interface IWegaRandomizerControllerEvents {
+ event RandomizerSet(address indexed newRandomizer);
+}

contracts/games/Wega.sol

@@ -19,7 +19,7 @@ import "@openzeppelin/contracts/utils/math/Math.sol";
 
 import "../escrow/WegaERC20Escrow.sol";
 import "../roles/WegaProtocolAdminRole.sol";
-import "../IWegaRandomNumberController.sol";
+import "../IWegaRandomizerController.sol";
 import "../errors/AccessControlErrors.sol";
 import "../utils/Arrays.sol";
 import "./IWega.sol";
@@ -32,7 +32,7 @@ abstract contract Wega is IWega, WegaProtocolAdminRole, UUPSUpgradeable {
   using Math for uint256;
   using Arrays for uint256[];
 
-  IWegaRandomNumberController internal randomNumberGen;
+  IWegaRandomizerController internal _randomizerController;
 
   // escrowHash -> address of the player -> results
   mapping(bytes32 => mapping(address => uint256[])) private _gameResults;
@@ -58,7 +58,7 @@ abstract contract Wega is IWega, WegaProtocolAdminRole, UUPSUpgradeable {
   } 
 
   function __Wega_init_unchained(address randomNumberController) public onlyInitializing {
-    randomNumberGen = IWegaRandomNumberController(randomNumberController);
+    _randomizerController = IWegaRandomizerController(randomNumberController);
   }
 
   function winners(bytes32 escrowHash) external view override returns(address[] memory) {
@@ -108,7 +108,7 @@ abstract contract Wega is IWega, WegaProtocolAdminRole, UUPSUpgradeable {
   }
 
   function randomNumbersContract() external view returns(address) {
-    return address(randomNumberGen);
+    return address(_randomizerController);
   }
 
   // coinflip

contracts/games/WegaCoinFlipGame.sol

@@ -12,7 +12,7 @@ import "@openzeppelin/contracts/utils/math/Math.sol";
 
 import "../escrow/WegaERC20Escrow.sol";
 import "../roles/WegaGameManagerRole.sol";
-import "../IWegaRandomNumberController.sol";
+import "../IWegaRandomizerController.sol";
 import "./Wega.sol";
 
 
@@ -45,17 +45,17 @@ contract WegaCoinFlipGame is Wega {
    }
 
    // users have chosen a coin to flip
-   uint256 coinflip = randomNumberGen.generate(denominator, _nonces.current());
-   _nonces.increment();
+   _randomizerController.incrementControllerNonce();
+   uint256 coinflip = _randomizerController.generate(denominator);
    for (uint256 i = 0; i < currentPlayers.length; i++) { 
       uint256 result;
      if(playerChoices[i] == coinflip) {
-      result = 1; // win 1 point
+      result = 1;
      } else {
-      result = 0; // lose 0 point
+      result = 0;
      }
-     _addResult(escrowHash, currentPlayers[i], result); // just sets result
-     _addScore(escrowHash, currentPlayers[i], result); // 1 point for 
+     _addResult(escrowHash, currentPlayers[i], result);
+     _addScore(escrowHash, currentPlayers[i], result); 
    }
     return _play(escrowHash, currentPlayers, playerChoices, denominator, currentRound + 1, minRounds);
   }

contracts/games/WegaDiceGame.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.8.19;
 /**
   * @title WegaDiceGame (MVP)
   * @author @RasenGUY @Daosourced.
-  * @notice a simple decentralized onchain dice game
+  * @notice a simple decentralized dice game
   * @dev note this is draft contract not meant to be used in production
 */
 import "@openzeppelin/contracts-upgradeable/utils/structs/EnumerableMapUpgradeable.sol";
@@ -13,7 +13,7 @@ import "@openzeppelin/contracts/utils/math/Math.sol";
 
 import "../escrow/WegaERC20Escrow.sol";
 import "../roles/WegaGameManagerRole.sol";
-import "../IWegaRandomNumberController.sol";
+import "../IWegaRandomizerController.sol";
 import "./Wega.sol";
 
 
@@ -45,8 +45,8 @@ contract WegaDiceGame is Wega {
     // roll dice
     uint256[] memory results = new uint256[](currentPlayers.length);
     for (uint256 i = 0; i < currentPlayers.length; i++) { 
-      results[i] = randomNumberGen.generate(denominator, _nonces.current());
-      _nonces.increment();
+      _randomizerController.incrementControllerNonce();
+      results[i] = _randomizerController.generate(denominator);
       _addResult(escrowHash, currentPlayers[i], results[i]);
     }
     _tallyResultsIntoScores(escrowHash, currentPlayers, results);

contracts/randomizer/IWegaRandomizer.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.14;
+
+interface IWegaRandomizer {
+
+    /**
+     * @notice returns the current length of randomnumbers set
+     */
+    function randomNumbersCount() external view returns (uint256);
+
+    /**
+     * @notice adds random numbers from a source to the random number set
+     * @param randomNumbers the randomnumber that should be added
+     */
+    function seed(uint256[] memory randomNumbers) external;
+
+    /**
+    * @notice retrieves a random number based on the current owner nonce
+    */
+    function retrieve() external view returns(uint256);
+
+    /**
+    * @notice increments the nonce for the game controller
+    */
+    function useOwnerNonce() external  returns (uint256);
+}