Merge branch 'minipool-approval'

Author: kanewallmann

contracts/contract/RocketStorage.sol

@@ -86,7 +86,7 @@ contract RocketStorage is RocketStorageInterface {
     }
 
     // Set this as being deployed now
-    function getDeployedStatus() external view returns (bool) {
+    function getDeployedStatus() external override view returns (bool) {
         return storageInit;
     }
 

contracts/contract/dao/node/settings/RocketDAONodeTrustedSettings.sol

@@ -46,12 +46,12 @@ abstract contract RocketDAONodeTrustedSettings is RocketBase, RocketDAONodeTrust
     /*** Bools  ****************/
 
     // A general method to return any setting given the setting path is correct, only accepts bools
-    function getSettingBool(string memory _settingPath) external view override returns (bool) {
+    function getSettingBool(string memory _settingPath) public view override returns (bool) {
         return getBool(keccak256(abi.encodePacked(settingNameSpace, _settingPath)));
     } 
 
     // Update a setting, can only be executed by the DAO contract when a majority on a setting proposal has passed and been executed
-    function setSettingBool(string memory _settingPath, bool _value) virtual external override onlyDAONodeTrustedProposal {
+    function setSettingBool(string memory _settingPath, bool _value) virtual public override onlyDAONodeTrustedProposal {
         // Update setting now
         setBool(keccak256(abi.encodePacked(settingNameSpace, _settingPath)), _value);
     }

contracts/contract/dao/node/settings/RocketDAONodeTrustedSettingsMinipool.sol

@@ -0,0 +1,71 @@
+pragma solidity 0.7.6;
+
+// SPDX-License-Identifier: GPL-3.0-only
+
+import "@openzeppelin/contracts/math/SafeMath.sol";
+
+import "./RocketDAONodeTrustedSettings.sol";
+import "../../../../interface/dao/node/settings/RocketDAONodeTrustedSettingsMinipoolInterface.sol";
+import "../../../../interface/dao/protocol/settings/RocketDAOProtocolSettingsMinipoolInterface.sol";
+
+
+// The Trusted Node DAO Minipool settings
+contract RocketDAONodeTrustedSettingsMinipool is RocketDAONodeTrustedSettings, RocketDAONodeTrustedSettingsMinipoolInterface {
+
+    using SafeMath for uint;
+
+    // Construct
+    constructor(RocketStorageInterface _rocketStorageAddress) RocketDAONodeTrustedSettings(_rocketStorageAddress, "minipool") {
+        // Set version
+        version = 1;
+
+        // If deployed during initial deployment, initialise now (otherwise must be called after upgrade)
+        if (!_rocketStorageAddress.getDeployedStatus()){
+            initialise();
+        }
+    }
+
+
+    // Initialise
+    function initialise() public {
+        // Initialize settings on deployment
+        require(!getBool(keccak256(abi.encodePacked(settingNameSpace, "deployed"))), "Already initialised");
+        // Init settings
+        setSettingUint("minipool.scrub.period", 12 hours);
+        setSettingUint("minipool.scrub.quorum", 0.51 ether);
+        setSettingBool("minipool.scrub.penalty.enabled", false);
+        // Settings initialised
+        setBool(keccak256(abi.encodePacked(settingNameSpace, "deployed")), true);
+    }
+
+
+    // Update a setting, overrides inherited setting method with extra checks for this contract
+    function setSettingUint(string memory _settingPath, uint256 _value) override public onlyDAONodeTrustedProposal {
+        // Some safety guards for certain settings
+        if(getBool(keccak256(abi.encodePacked(settingNameSpace, "deployed")))) {
+            if(keccak256(abi.encodePacked(_settingPath)) == keccak256(abi.encodePacked("minipool.scrub.period"))) {
+                RocketDAOProtocolSettingsMinipoolInterface rocketDAOProtocolSettingsMinipool = RocketDAOProtocolSettingsMinipoolInterface(getContractAddress("rocketDAOProtocolSettingsMinipool"));
+                require(_value <= (rocketDAOProtocolSettingsMinipool.getLaunchTimeout().sub(1 hours)), "Scrub period must be less than launch timeout");
+            }
+        }
+        // Update setting now
+        setUint(keccak256(abi.encodePacked(settingNameSpace, _settingPath)), _value);
+    }
+
+    // Getters
+
+    // How long minipools must wait before moving to staking status (can be scrubbed by ODAO before then)
+    function getScrubPeriod() override external view returns (uint256) {
+        return getSettingUint("minipool.scrub.period");
+    }
+
+    // The required number of trusted nodes to vote to scrub a minipool
+    function getScrubQuorum() override external view returns (uint256) {
+        return getSettingUint("minipool.scrub.quorum");
+    }
+
+    // True if scrubbing results in an RPL penalty for the node operator
+    function getScrubPenaltyEnabled() override external view returns (bool) {
+        return getSettingBool("minipool.scrub.penalty.enabled");
+    }
+}

contracts/contract/dao/protocol/settings/RocketDAOProtocolSettingsMinipool.sol

@@ -6,6 +6,7 @@ import "@openzeppelin/contracts/math/SafeMath.sol";
 
 import "./RocketDAOProtocolSettings.sol";
 import "../../../../interface/dao/protocol/settings/RocketDAOProtocolSettingsMinipoolInterface.sol";
+import "../../../../interface/dao/node/settings/RocketDAONodeTrustedSettingsMinipoolInterface.sol";
 import "../../../../types/MinipoolDeposit.sol";
 
 // Network minipool settings
@@ -22,13 +23,26 @@ contract RocketDAOProtocolSettingsMinipool is RocketDAOProtocolSettings, RocketD
         if(!getBool(keccak256(abi.encodePacked(settingNameSpace, "deployed")))) {
             // Apply settings
             setSettingBool("minipool.submit.withdrawable.enabled", false);
-            setSettingUint("minipool.launch.timeout", 5760);                // ~24 hours
+            setSettingUint("minipool.launch.timeout", 72 hours);
             setSettingUint("minipool.maximum.count", 14);
             // Settings initialised
             setBool(keccak256(abi.encodePacked(settingNameSpace, "deployed")), true);
         }
     }
 
+    // Update a setting, overrides inherited setting method with extra checks for this contract
+    function setSettingUint(string memory _settingPath, uint256 _value) override public onlyDAOProtocolProposal {
+        // Some safety guards for certain settings
+        if(getBool(keccak256(abi.encodePacked(settingNameSpace, "deployed")))) {
+            if(keccak256(abi.encodePacked(_settingPath)) == keccak256(abi.encodePacked("minipool.launch.timeout"))) {
+                RocketDAONodeTrustedSettingsMinipoolInterface rocketDAONodeTrustedSettingsMinipool = RocketDAONodeTrustedSettingsMinipoolInterface(getContractAddress("rocketDAONodeTrustedSettingsMinipool"));
+                require(_value >= (rocketDAONodeTrustedSettingsMinipool.getScrubPeriod().add(1 hours)), "Launch timeout must be greater than scrub period");
+            }
+        }
+        // Update setting now
+        setUint(keccak256(abi.encodePacked(settingNameSpace, _settingPath)), _value);
+    }
+
     // Balance required to launch minipool
     function getLaunchBalance() override public pure returns (uint256) {
         return 32 ether;
@@ -73,7 +87,7 @@ contract RocketDAOProtocolSettingsMinipool is RocketDAOProtocolSettings, RocketD
         return getSettingBool("minipool.submit.withdrawable.enabled");
     }
 
-    // Timeout period in blocks for prelaunch minipools to launch
+    // Timeout period in seconds for prelaunch minipools to launch
     function getLaunchTimeout() override external view returns (uint256) {
         return getSettingUint("minipool.launch.timeout");
     }

contracts/contract/dao/protocol/settings/RocketDAOProtocolSettingsRewards.sol

@@ -23,7 +23,7 @@ contract RocketDAOProtocolSettingsRewards is RocketDAOProtocolSettings, RocketDA
             setSettingRewardsClaimer('rocketClaimNode', 0.70 ether);                                            // Bonded Node Rewards claim % amount - Percentage given of 1 ether
             setSettingRewardsClaimer('rocketClaimTrustedNode', 0.2 ether);                                      // Trusted Node Rewards claim % amount - Percentage given of 1 ether
             // RPL Claims settings
-            setSettingUint("rpl.rewards.claim.period.time", 28 days);                                           // The time in which a claim period will span in seconds - 14 days by default
+            setSettingUint("rpl.rewards.claim.period.time", 28 days);                                           // The time in which a claim period will span in seconds - 28 days by default
             // Deployment check
             setBool(keccak256(abi.encodePacked(settingNameSpace, "deployed")), true);                           // Flag that this contract has been deployed, so default settings don't get reapplied on a contract upgrade
         }