StakerV3 implementation

.sample-env

@@ -1,3 +1,6 @@
 INFURA_PROJECT_ID=
 DEPLOYER_PRIVATE_KEY=
 ETHERSCAN_API_KEY=
+ALCHEMY_KEY=
+REPORT_GAS=
+COINMARKETCAP_API_KEY=

.solcover.js

@@ -1,4 +1,4 @@
 // Exclude the legacy compiler MultiSigWallet.sol file from instrumentation.
 module.exports = {
-  skipFiles: [ 'MultiSigWallet.sol' ]
+  skipFiles: ["MultiSigWallet.sol"],
 };

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+  "solidity.compileUsingRemoteVersion": "v0.8.8+commit.dddeac2f",
+  "solidity-va.uml.actors.enable": false
+}

contracts/access/PermitControl.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.7;
 
 import "@openzeppelin/contracts/access/Ownable.sol";
 import "@openzeppelin/contracts/utils/Address.sol";
+import "hardhat/console.sol";
 
 /**
   @title An advanced permission-management contract.
@@ -18,21 +19,21 @@ import "@openzeppelin/contracts/utils/Address.sol";
   August 23rd, 2021.
 */
 abstract contract PermitControl is Ownable {
-  using Address for address;
+    using Address for address;
 
-  /// A special reserved constant for representing no rights.
-  bytes32 public constant ZERO_RIGHT = hex"00000000000000000000000000000000";
+    /// A special reserved constant for representing no rights.
+    bytes32 public constant ZERO_RIGHT = hex"00000000000000000000000000000000";
 
-  /// A special constant specifying the unique, universal-rights circumstance.
-  bytes32 public constant UNIVERSAL = hex"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF";
+    /// A special constant specifying the unique, universal-rights circumstance.
+    bytes32 public constant UNIVERSAL = hex"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF";
 
-  /*
+    /*
     A special constant specifying the unique manager right. This right allows an
     address to freely-manipulate the `managedRight` mapping.
   **/
-  bytes32 public constant MANAGER = hex"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF";
+    bytes32 public constant MANAGER = hex"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF";
 
-  /**
+    /**
     A mapping of per-address permissions to the circumstances, represented as
     an additional layer of generic bytes32 data, under which the addresses have
     various permits. A permit in this sense is represented by a per-circumstance
@@ -45,19 +46,19 @@ abstract contract PermitControl is Ownable {
     max-integer circumstance. Perpetual rights may be given an expiry time of
     max-integer.
   */
-  mapping( address => mapping( bytes32 => mapping( bytes32 => uint256 )))
-    public permissions;
+    mapping(address => mapping(bytes32 => mapping(bytes32 => uint256)))
+        public permissions;
 
-  /**
+    /**
     An additional mapping of managed rights to manager rights. This mapping
     represents the administrator relationship that various rights have with one
     another. An address with a manager right may freely set permits for that
     manager right's managed rights. Each right may be managed by only one other
     right.
   */
-  mapping( bytes32 => bytes32 ) public managerRight;
+    mapping(bytes32 => bytes32) public managerRight;
 
-  /**
+    /**
     An event emitted when an address has a permit updated. This event captures,
     through its various parameter combinations, the cases of granting a permit,
     updating the expiration time of a permit, or revoking a permit.
@@ -68,32 +69,32 @@ abstract contract PermitControl is Ownable {
     @param role The role which was updated.
     @param expirationTime The time when the permit expires.
   */
-  event PermitUpdated(
-    address indexed updator,
-    address indexed updatee,
-    bytes32 circumstance,
-    bytes32 indexed role,
-    uint256 expirationTime
-  );
-
-//   /**
-//     A version of PermitUpdated for work with setPermits() function.
-    
-//     @param updator The address which has updated the permit.
-//     @param updatees The addresses whose permit were updated.
-//     @param circumstances The circumstances wherein the permits were updated.
-//     @param roles The roles which were updated.
-//     @param expirationTimes The times when the permits expire.
-//   */
-//   event PermitsUpdated(
-//     address indexed updator,
-//     address[] indexed updatees,
-//     bytes32[] circumstances,
-//     bytes32[] indexed roles,
-//     uint256[] expirationTimes
-//   );
-
-  /**
+    event PermitUpdated(
+        address indexed updator,
+        address indexed updatee,
+        bytes32 circumstance,
+        bytes32 indexed role,
+        uint256 expirationTime
+    );
+
+    //   /**
+    //     A version of PermitUpdated for work with setPermits() function.
+
+    //     @param updator The address which has updated the permit.
+    //     @param updatees The addresses whose permit were updated.
+    //     @param circumstances The circumstances wherein the permits were updated.
+    //     @param roles The roles which were updated.
+    //     @param expirationTimes The times when the permits expire.
+    //   */
+    //   event PermitsUpdated(
+    //     address indexed updator,
+    //     address[] indexed updatees,
+    //     bytes32[] circumstances,
+    //     bytes32[] indexed roles,
+    //     uint256[] expirationTimes
+    //   );
+
+    /**
     An event emitted when a management relationship in `managerRight` is
     updated. This event captures adding and revoking management permissions via
     observing the update history of the `managerRight` value.
@@ -102,13 +103,13 @@ abstract contract PermitControl is Ownable {
     @param managedRight The right which had its manager updated.
     @param managerRight The new manager right which was updated to.
   */
-  event ManagementUpdated(
-    address indexed manager,
-    bytes32 indexed managedRight,
-    bytes32 indexed managerRight
-  );
+    event ManagementUpdated(
+        address indexed manager,
+        bytes32 indexed managedRight,
+        bytes32 indexed managerRight
+    );
 
-  /**
+    /**
     A modifier which allows only the super-administrative owner or addresses
     with a specified valid right to perform a call.
 
@@ -117,24 +118,23 @@ abstract contract PermitControl is Ownable {
     @param _right The right to validate for the calling address. It must be
       non-expired and exist within the specified `_circumstance`.
   */
-  modifier hasValidPermit(
-    bytes32 _circumstance,
-    bytes32 _right
-  ) {
-    require(_msgSender() == owner()
-      || hasRight(_msgSender(), _circumstance, _right),
-      "P1");
-    _;
-  }
-
-  /**
+    modifier hasValidPermit(bytes32 _circumstance, bytes32 _right) {
+        require(
+            _msgSender() == owner() ||
+                hasRight(_msgSender(), _circumstance, _right),
+            "P1"
+        );
+        _;
+    }
+
+    /**
     Return a version number for this contract's interface.
   */
-  function version() external virtual pure returns (uint256) {
-    return 1;
-  }
+    function version() external pure virtual returns (uint256) {
+        return 1;
+    }
 
-  /**
+    /**
     Determine whether or not an address has some rights under the given
     circumstance, and if they do have the right, until when.
 
@@ -144,15 +144,15 @@ abstract contract PermitControl is Ownable {
     @return The timestamp in seconds when the `_right` expires. If the timestamp
       is zero, we can assume that the user never had the right.
   */
-  function hasRightUntil(
-    address _address,
-    bytes32 _circumstance,
-    bytes32 _right
-  ) public view returns (uint256) {
-    return permissions[_address][_circumstance][_right];
-  }
-
-   /**
+    function hasRightUntil(
+        address _address,
+        bytes32 _circumstance,
+        bytes32 _right
+    ) public view returns (uint256) {
+        return permissions[_address][_circumstance][_right];
+    }
+
+    /**
     Determine whether or not an address has some rights under the given
     circumstance,
 
@@ -161,15 +161,15 @@ abstract contract PermitControl is Ownable {
     @param _right The right to check for validity.
     @return true or false, whether user has rights and time is valid.
   */
-  function hasRight(
-    address _address,
-    bytes32 _circumstance,
-    bytes32 _right
-  ) public view returns (bool) {
-    return permissions[_address][_circumstance][_right] > block.timestamp;
-  }
-
-  /**
+    function hasRight(
+        address _address,
+        bytes32 _circumstance,
+        bytes32 _right
+    ) public view returns (bool) {
+        return permissions[_address][_circumstance][_right] > block.timestamp;
+    }
+
+    /**
     Set the permit to a specific address under some circumstances. A permit may
     only be set by the super-administrative contract owner or an address holding
     some delegated management permit.
@@ -180,59 +180,63 @@ abstract contract PermitControl is Ownable {
     @param _expirationTime The time when the `_right` expires for the provided
       `_circumstance`.
   */
-  function setPermit(
-    address _address,
-    bytes32 _circumstance,
-    bytes32 _right,
-    uint256 _expirationTime
-  ) public virtual hasValidPermit(UNIVERSAL, managerRight[_right]) {
-    require(_right != ZERO_RIGHT,
-      "P2");
-    permissions[_address][_circumstance][_right] = _expirationTime;
-    emit PermitUpdated(_msgSender(), _address, _circumstance, _right,
-      _expirationTime);
-  }
-
-//   /**
-//     Version of setPermit() that works with multiple addresses in one transaction.
-
-//     @param _addresses The array of addresses to assign the specified `_right` to.
-//     @param _circumstances The array of circumstances in which the `_right` is 
-//                           valid.
-//     @param _rights The array of specific rights to assign.
-//     @param _expirationTimes The array of times when the `_rights` expires for 
-//                             the provided _circumstance`.
-//   */
-//   function setPermits(
-//     address[] memory _addresses,
-//     bytes32[] memory _circumstances, 
-//     bytes32[] memory _rights, 
-//     uint256[] memory _expirationTimes
-//   ) public virtual {
-//     require((_addresses.length == _circumstances.length)
-//              && (_circumstances.length == _rights.length)
-//              && (_rights.length == _expirationTimes.length),
-//              "leghts of input arrays are not equal"
-//     );
-//     bytes32 lastRight;
-//     for(uint i = 0; i < _rights.length; i++) {
-//       if (lastRight != _rights[i] || (i == 0)) { 
-//         require(_msgSender() == owner() || hasRight(_msgSender(), _circumstances[i], _rights[i]), "P1");
-//         require(_rights[i] != ZERO_RIGHT, "P2");
-//         lastRight = _rights[i];
-//       }
-//       permissions[_addresses[i]][_circumstances[i]][_rights[i]] = _expirationTimes[i];
-//     }
-//     emit PermitsUpdated(
-//       _msgSender(), 
-//       _addresses,
-//       _circumstances,
-//       _rights,
-//       _expirationTimes
-//     );
-//   }
-
-  /**
+    function setPermit(
+        address _address,
+        bytes32 _circumstance,
+        bytes32 _right,
+        uint256 _expirationTime
+    ) public virtual hasValidPermit(UNIVERSAL, managerRight[_right]) {
+        require(_right != ZERO_RIGHT, "P2");
+        permissions[_address][_circumstance][_right] = _expirationTime;
+        emit PermitUpdated(
+            _msgSender(),
+            _address,
+            _circumstance,
+            _right,
+            _expirationTime
+        );
+    }
+
+    //   /**
+    //     Version of setPermit() that works with multiple addresses in one transaction.
+
+    //     @param _addresses The array of addresses to assign the specified `_right` to.
+    //     @param _circumstances The array of circumstances in which the `_right` is
+    //                           valid.
+    //     @param _rights The array of specific rights to assign.
+    //     @param _expirationTimes The array of times when the `_rights` expires for
+    //                             the provided _circumstance`.
+    //   */
+    //   function setPermits(
+    //     address[] memory _addresses,
+    //     bytes32[] memory _circumstances,
+    //     bytes32[] memory _rights,
+    //     uint256[] memory _expirationTimes
+    //   ) public virtual {
+    //     require((_addresses.length == _circumstances.length)
+    //              && (_circumstances.length == _rights.length)
+    //              && (_rights.length == _expirationTimes.length),
+    //              "leghts of input arrays are not equal"
+    //     );
+    //     bytes32 lastRight;
+    //     for(uint i = 0; i < _rights.length; i++) {
+    //       if (lastRight != _rights[i] || (i == 0)) {
+    //         require(_msgSender() == owner() || hasRight(_msgSender(), _circumstances[i], _rights[i]), "P1");
+    //         require(_rights[i] != ZERO_RIGHT, "P2");
+    //         lastRight = _rights[i];
+    //       }
+    //       permissions[_addresses[i]][_circumstances[i]][_rights[i]] = _expirationTimes[i];
+    //     }
+    //     emit PermitsUpdated(
+    //       _msgSender(),
+    //       _addresses,
+    //       _circumstances,
+    //       _rights,
+    //       _expirationTimes
+    //     );
+    //   }
+
+    /**
     Set the `_managerRight` whose `UNIVERSAL` holders may freely manage the
     specified `_managedRight`.
 
@@ -241,13 +245,13 @@ abstract contract PermitControl is Ownable {
     @param _managerRight The right whose `UNIVERSAL` holders may manage
       `_managedRight`.
   */
-  function setManagerRight(
-    bytes32 _managedRight,
-    bytes32 _managerRight
-  ) external virtual hasValidPermit(UNIVERSAL, MANAGER) {
-    require(_managedRight != ZERO_RIGHT,
-      "P3");
-    managerRight[_managedRight] = _managerRight;
-    emit ManagementUpdated(_msgSender(), _managedRight, _managerRight);
-  }
-}
+    function setManagerRight(bytes32 _managedRight, bytes32 _managerRight)
+        external
+        virtual
+        hasValidPermit(UNIVERSAL, MANAGER)
+    {
+        require(_managedRight != ZERO_RIGHT, "P3");
+        managerRight[_managedRight] = _managerRight;
+        emit ManagementUpdated(_msgSender(), _managedRight, _managerRight);
+    }
+}