Merge remote-tracking branch 'origin/master' into fully-backed-tweaks

Author: nkuba

.github/workflows/solidity-test.yml

@@ -16,7 +16,7 @@ jobs:
       - name: Run tests
         # Runs ganache in background
         run: |
-          npm run ganache & 
+          npm run buidler-vm & 
           npm test
         env:
           CI: true

buidler.config.js

@@ -0,0 +1 @@
+module.exports = {};

contracts/Leaf.sol

@@ -24,19 +24,19 @@ library Leaf {
   ////////////////////////////////////////////////////////////////////////////
 
   function make(
-    address operator,
-    uint256 creationBlock,
-    uint256 weight
+    address _operator,
+    uint256 _creationBlock,
+    uint256 _weight
   ) internal pure returns (uint256) {
     // Converting a bytesX type into a larger type
     // adds zero bytes on the right.
-    uint256 op = uint256(bytes32(bytes20(operator)));
+    uint256 op = uint256(bytes32(bytes20(_operator)));
     // Bitwise AND the weight to erase
     // all but the 32 least significant bits
-    uint256 wt = weight & WEIGHT_MAX;
+    uint256 wt = _weight & WEIGHT_MAX;
     // Erase all but the 64 least significant bits,
     // then shift left by 32 bits to make room for the weight
-    uint256 cb = (creationBlock & BLOCKHEIGHT_MAX) << WEIGHT_WIDTH;
+    uint256 cb = (_creationBlock & BLOCKHEIGHT_MAX) << WEIGHT_WIDTH;
     // Bitwise OR them all together to get
     // [address operator || uint64 creationBlock || uint32 weight]
     return (op | cb | wt);

contracts/RNG.sol

@@ -12,12 +12,12 @@ library RNG {
   // How many bits a position uses per level of the tree;
   // each branch of the tree contains 2**SLOT_BITS slots.
   uint256 constant SLOT_BITS = 3;
-  uint256 constant LEVELS = 7;
   ////////////////////////////////////////////////////////////////////////////
 
   ////////////////////////////////////////////////////////////////////////////
   // Derived constants, do not touch
-  uint256 constant POSITION_BITS = LEVELS * SLOT_BITS;
+  uint256 constant SLOT_COUNT = 2**SLOT_BITS;
+  uint256 constant WEIGHT_WIDTH = 256 / SLOT_COUNT;
   ////////////////////////////////////////////////////////////////////////////
 
   struct State {
@@ -127,30 +127,26 @@ library RNG {
   /// @notice Calculate how many bits are required
   /// for an index in the range `[0 .. range-1]`.
   ///
-  /// @dev Our sortition pool can support up to 2^21 virtual stakers,
-  /// therefore we calculate how many bits we need from 1 to 21.
-  ///
   /// @param range The upper bound of the desired range, exclusive.
   ///
   /// @return uint The smallest number of bits
   /// that can contain the number `range-1`.
   function bitsRequired(uint256 range) internal pure returns (uint256) {
-    uint256 bits;
-    // Start at 19 to be faster for large ranges
-    for (bits = (POSITION_BITS - 1); bits >= 0; bits--) {
-      // Left shift by `bits`,
-      // so we have a 1 in the (bits + 1)th least significant bit
-      // and 0 in other bits.
-      // If this number is equal or greater than `range`,
-      // the range [0, range-1] fits in `bits` bits.
-      //
-      // Because we loop from high bits to low bits,
-      // we find the highest number of bits that doesn't fit the range,
-      // and return that number + 1.
-      if (1 << bits < range) {
-        break;
-      }
+    uint256 bits = WEIGHT_WIDTH - 1;
+
+    // Left shift by `bits`,
+    // so we have a 1 in the (bits + 1)th least significant bit
+    // and 0 in other bits.
+    // If this number is equal or greater than `range`,
+    // the range [0, range-1] fits in `bits` bits.
+    //
+    // Because we loop from high bits to low bits,
+    // we find the highest number of bits that doesn't fit the range,
+    // and return that number + 1.
+    while (1 << bits >= range) {
+      bits--;
     }
+
     return bits + 1;
   }
 
@@ -197,7 +193,7 @@ library RNG {
   {
     uint256 bits = bitsRequired(range);
     bool found = false;
-    uint256 index;
+    uint256 index = 0;
     bytes32 newState = state;
     while (!found) {
       index = truncate(bits, uint256(newState));