Merge branch 'v1.1-merge'

Author: kanewallmann

contracts/contract/dao/node/RocketDAONodeTrustedActions.sol

@@ -36,15 +36,14 @@ contract RocketDAONodeTrustedActions is RocketBase, RocketDAONodeTrustedActionsI
     // Construct
     constructor(RocketStorageInterface _rocketStorageAddress) RocketBase(_rocketStorageAddress) {
         // Version
-        version = 1;
+        version = 2;
     }
 
     /*** Internal Methods **********************/
 
     // Add a new member to the DAO
     function _memberAdd(address _nodeAddress, uint256 _rplBondAmountPaid) private onlyRegisteredNode(_nodeAddress) {
         // Load contracts
-        RocketClaimTrustedNodeInterface rocketClaimTrustedNode = RocketClaimTrustedNodeInterface(getContractAddress("rocketClaimTrustedNode"));
         RocketDAONodeTrustedInterface rocketDAONode = RocketDAONodeTrustedInterface(getContractAddress("rocketDAONodeTrusted"));
         AddressSetStorageInterface addressSetStorage = AddressSetStorageInterface(getContractAddress("addressSetStorage"));
         // Check current node status
@@ -57,17 +56,12 @@ contract RocketDAONodeTrustedActions is RocketBase, RocketDAONodeTrustedActionsI
         setUint(keccak256(abi.encodePacked(daoNameSpace, "member.joined.time", _nodeAddress)), block.timestamp);
          // Add to member index now
         addressSetStorage.addItem(keccak256(abi.encodePacked(daoNameSpace, "member.index")), _nodeAddress); 
-        // Register for them to receive rewards now
-        rocketClaimTrustedNode.register(_nodeAddress, true);
     }
 
     // Remove a member from the DAO
     function _memberRemove(address _nodeAddress) private onlyTrustedNode(_nodeAddress) {
         // Load contracts
-        RocketClaimTrustedNodeInterface rocketClaimTrustedNode = RocketClaimTrustedNodeInterface(getContractAddress("rocketClaimTrustedNode"));
         AddressSetStorageInterface addressSetStorage = AddressSetStorageInterface(getContractAddress("addressSetStorage"));
-        // Deregister them from receiving rewards now
-        rocketClaimTrustedNode.register(_nodeAddress, false);
         // Remove their membership now
         deleteBool(keccak256(abi.encodePacked(daoNameSpace, "member", _nodeAddress)));
         deleteAddress(keccak256(abi.encodePacked(daoNameSpace, "member.address", _nodeAddress)));

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

@@ -0,0 +1,50 @@
+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/RocketDAONodeTrustedSettingsRewardsInterface.sol";
+import "../../../../interface/dao/protocol/settings/RocketDAOProtocolSettingsRewardsInterface.sol";
+
+
+// The Trusted Node DAO Rewards settings
+
+contract RocketDAONodeTrustedSettingsRewards is RocketDAONodeTrustedSettings, RocketDAONodeTrustedSettingsRewardsInterface {
+
+    using SafeMath for uint;
+
+    // Construct
+    constructor(RocketStorageInterface _rocketStorageAddress) RocketDAONodeTrustedSettings(_rocketStorageAddress, "rewards") {
+        // Set version
+        version = 2;
+        // Initialize settings on deployment
+        if(!getBool(keccak256(abi.encodePacked(settingNameSpace, "deployed")))) {
+            // Init settings
+            setSettingBool("rewards.network.enabled", true);
+            // Settings initialised
+            setBool(keccak256(abi.encodePacked(settingNameSpace, "deployed")), true);
+        }
+    }
+
+    // Update a setting, overrides inherited setting method with extra checks for this contract
+    function setSettingBool(string memory _settingPath, bool _value) override public onlyDAONodeTrustedProposal {
+        // Some safety guards for certain settings
+        if(getBool(keccak256(abi.encodePacked(settingNameSpace, "deployed")))) {
+            // oDAO should never disable main net rewards
+            if(keccak256(abi.encodePacked(_settingPath)) == keccak256(abi.encodePacked("rewards.network.enabled", uint256(0)))) {
+                revert("Cannot disable network 0");
+            }
+        }
+        // Update setting now
+        setBool(keccak256(abi.encodePacked(settingNameSpace, _settingPath)), _value);
+    }
+
+
+    // Getters
+
+    function getNetworkEnabled(uint256 _network) override external view returns (bool) {
+        return getBool(keccak256(abi.encodePacked(settingNameSpace, "rewards.network.enabled", _network)));
+    }
+}

contracts/contract/dao/protocol/RocketDAOProtocol.sol

@@ -71,7 +71,6 @@ contract RocketDAOProtocol is RocketBase, RocketDAOProtocolInterface {
 
     // Bootstrap mode -Spend DAO treasury
     function bootstrapSpendTreasury(string memory _invoiceID, address _recipientAddress, uint256 _amount) override external onlyGuardian onlyBootstrapMode onlyLatestContract("rocketDAOProtocol", address(this)) {
-        // Ok good to go, lets update the rewards claiming contract amount 
         RocketDAOProtocolProposalsInterface(getContractAddress("rocketDAOProtocolProposals")).proposalSpendTreasury(_invoiceID, _recipientAddress, _amount);
     }
 

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

@@ -12,7 +12,7 @@ contract RocketDAOProtocolSettingsDeposit is RocketDAOProtocolSettings, RocketDA
     // Construct
     constructor(RocketStorageInterface _rocketStorageAddress) RocketDAOProtocolSettings(_rocketStorageAddress, "deposit") {
         // Set version
-        version = 1;
+        version = 2;
         // Initialize settings on deployment
         if(!getBool(keccak256(abi.encodePacked(settingNameSpace, "deployed")))) {
             // Apply settings
@@ -21,6 +21,7 @@ contract RocketDAOProtocolSettingsDeposit is RocketDAOProtocolSettings, RocketDA
             setSettingUint("deposit.minimum", 0.01 ether);
             setSettingUint("deposit.pool.maximum", 160 ether);
             setSettingUint("deposit.assign.maximum", 2);
+            setSettingUint("deposit.fee", 0.0005 ether);    // Set to approx. 1 day of rewards at 18.25% APR
             // Settings initialised
             setBool(keccak256(abi.encodePacked(settingNameSpace, "deployed")), true);
         }
@@ -51,4 +52,8 @@ contract RocketDAOProtocolSettingsDeposit is RocketDAOProtocolSettings, RocketDA
         return getSettingUint("deposit.assign.maximum");
     }
 
+    // Get the fee paid on deposits
+    function getDepositFee() override external view returns (uint256) {
+        return getSettingUint("deposit.fee");
+    }
 }

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

@@ -8,11 +8,10 @@ import "../../../../interface/dao/protocol/settings/RocketDAOProtocolSettingsNet
 // Network auction settings
 
 contract RocketDAOProtocolSettingsNetwork is RocketDAOProtocolSettings, RocketDAOProtocolSettingsNetworkInterface {
-
     // Construct
     constructor(RocketStorageInterface _rocketStorageAddress) RocketDAOProtocolSettings(_rocketStorageAddress, "network") {
         // Set version
-        version = 1;
+        version = 2;
         // Initialize settings on deployment
         if(!getBool(keccak256(abi.encodePacked(settingNameSpace, "deployed")))) {
             // Apply settings
@@ -26,7 +25,9 @@ contract RocketDAOProtocolSettingsNetwork is RocketDAOProtocolSettings, RocketDA
             setSettingUint("network.node.fee.maximum", 0.15 ether);         // 15%
             setSettingUint("network.node.fee.demand.range", 160 ether);
             setSettingUint("network.reth.collateral.target", 0.1 ether);
-            setSettingUint("network.reth.deposit.delay", 5760);            // ~24 hours
+            setSettingUint("network.penalty.threshold", 0.51 ether);       // Consensus for penalties requires 51% vote
+            setSettingUint("network.penalty.per.rate", 0.1 ether);         // 10% per penalty
+            setSettingBool("network.submit.rewards.enabled", true);        // Enable reward submission
             // Settings initialised
             setBool(keccak256(abi.encodePacked(settingNameSpace, "deployed")), true);
         }
@@ -49,7 +50,17 @@ contract RocketDAOProtocolSettingsNetwork is RocketDAOProtocolSettings, RocketDA
         return getSettingUint("network.consensus.threshold");
     }
 
-    // Submit balances currently enabled (trusted nodes only)
+    // The threshold of trusted nodes that must reach consensus on a penalty
+    function getNodePenaltyThreshold() override external view returns (uint256) {
+        return getSettingUint("network.penalty.threshold");
+    }
+
+    // The amount to penalise a minipool for each feeDistributor infraction
+    function getPerPenaltyRate() override external view returns (uint256) {
+        return getSettingUint("network.penalty.per.rate");
+    }
+
+// Submit balances currently enabled (trusted nodes only)
     function getSubmitBalancesEnabled() override external view returns (bool) {
         return getSettingBool("network.submit.balances.enabled");
     }
@@ -98,4 +109,9 @@ contract RocketDAOProtocolSettingsNetwork is RocketDAOProtocolSettings, RocketDA
     function getRethDepositDelay() override external view returns (uint256) {
         return getSettingUint("network.reth.deposit.delay");
     }
+
+    // Submit reward snapshots currently enabled (trusted nodes only)
+    function getSubmitRewardsEnabled() override external view returns (bool) {
+        return getSettingBool("network.submit.rewards.enabled");
+    }
 }

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

@@ -12,11 +12,12 @@ contract RocketDAOProtocolSettingsNode is RocketDAOProtocolSettings, RocketDAOPr
     // Construct
     constructor(RocketStorageInterface _rocketStorageAddress) RocketDAOProtocolSettings(_rocketStorageAddress, "node") {
         // Set version
-        version = 1;
+        version = 2;
         // Initialize settings on deployment
         if(!getBool(keccak256(abi.encodePacked(settingNameSpace, "deployed")))) {
             // Apply settings
             setSettingBool("node.registration.enabled", false);
+            setSettingBool("node.smoothing.pool.registration.enabled", true);
             setSettingBool("node.deposit.enabled", false);
             setSettingUint("node.per.minipool.stake.minimum", 0.1 ether);      // 10% of user ETH value
             setSettingUint("node.per.minipool.stake.maximum", 1.5 ether);      // 150% of user ETH value
@@ -30,6 +31,11 @@ contract RocketDAOProtocolSettingsNode is RocketDAOProtocolSettings, RocketDAOPr
         return getSettingBool("node.registration.enabled");
     }
 
+    // Node smoothing pool registrations currently enabled
+    function getSmoothingPoolRegistrationEnabled() override external view returns (bool) {
+        return getSettingBool("node.smoothing.pool.registration.enabled");
+    }
+
     // Node deposits currently enabled
     function getDepositEnabled() override external view returns (bool) {
         return getSettingBool("node.deposit.enabled");

contracts/contract/deposit/RocketDepositPool.sol

@@ -12,6 +12,7 @@ import "../../interface/minipool/RocketMinipoolInterface.sol";
 import "../../interface/minipool/RocketMinipoolQueueInterface.sol";
 import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsDepositInterface.sol";
 import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsMinipoolInterface.sol";
+import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsNetworkInterface.sol";
 import "../../interface/token/RocketTokenRETHInterface.sol";
 import "../../types/MinipoolDeposit.sol";
 
@@ -45,7 +46,7 @@ contract RocketDepositPool is RocketBase, RocketDepositPoolInterface, RocketVaul
 
     // Construct
     constructor(RocketStorageInterface _rocketStorageAddress) RocketBase(_rocketStorageAddress) {
-        version = 1;
+        version = 2;
     }
 
     // Current deposit pool balance
@@ -77,11 +78,12 @@ contract RocketDepositPool is RocketBase, RocketDepositPoolInterface, RocketVaul
         require(msg.value >= rocketDAOProtocolSettingsDeposit.getMinimumDeposit(), "The deposited amount is less than the minimum deposit size");
         RocketVaultInterface rocketVault = RocketVaultInterface(getContractAddress("rocketVault"));
         require(rocketVault.balanceOf("rocketDepositPool").add(msg.value) <= rocketDAOProtocolSettingsDeposit.getMaximumDepositPoolSize(), "The deposit pool size after depositing exceeds the maximum size");
-        // Record last deposit to time delay ability to withdraw
-        setUint(keccak256(abi.encodePacked("user.deposit.block", msg.sender)), block.number);
+        // Calculate deposit fee
+        uint256 depositFee = msg.value.mul(rocketDAOProtocolSettingsDeposit.getDepositFee()).div(calcBase);
+        uint256 depositNet = msg.value.sub(depositFee);
         // Mint rETH to user account
         RocketTokenRETHInterface rocketTokenRETH = RocketTokenRETHInterface(getContractAddress("rocketTokenRETH"));
-        rocketTokenRETH.mint(msg.value, msg.sender);
+        rocketTokenRETH.mint(depositNet, msg.sender);
         // Emit deposit received event
         emit DepositReceived(msg.sender, msg.value, block.timestamp);
         // Process deposit
@@ -121,11 +123,11 @@ contract RocketDepositPool is RocketBase, RocketDepositPoolInterface, RocketVaul
     }
 
     // Process a deposit
-    function processDeposit(RocketVaultInterface rocketVault, RocketDAOProtocolSettingsDepositInterface rocketDAOProtocolSettingsDeposit) private {
+    function processDeposit(RocketVaultInterface _rocketVault, RocketDAOProtocolSettingsDepositInterface _rocketDAOProtocolSettingsDeposit) private {
         // Transfer ETH to vault
-        rocketVault.depositEther{value: msg.value}();
+        _rocketVault.depositEther{value: msg.value}();
         // Assign deposits if enabled
-        _assignDeposits(rocketVault, rocketDAOProtocolSettingsDeposit);
+        _assignDeposits(_rocketVault, _rocketDAOProtocolSettingsDeposit);
     }
 
     // Assign deposits to available minipools
@@ -138,19 +140,19 @@ contract RocketDepositPool is RocketBase, RocketDepositPoolInterface, RocketVaul
     }
 
     // Assigns deposits to available minipools, returns false if assignment is currently disabled
-    function _assignDeposits(RocketVaultInterface rocketVault, RocketDAOProtocolSettingsDepositInterface rocketDAOProtocolSettingsDeposit) private returns (bool) {
+    function _assignDeposits(RocketVaultInterface _rocketVault, RocketDAOProtocolSettingsDepositInterface _rocketDAOProtocolSettingsDeposit) private returns (bool) {
         // Check if assigning deposits is enabled
-        if (!rocketDAOProtocolSettingsDeposit.getAssignDepositsEnabled()) {
+        if (!_rocketDAOProtocolSettingsDeposit.getAssignDepositsEnabled()) {
             return false;
         }
         // Load contracts
         RocketDAOProtocolSettingsMinipoolInterface rocketDAOProtocolSettingsMinipool = RocketDAOProtocolSettingsMinipoolInterface(getContractAddress("rocketDAOProtocolSettingsMinipool"));
         RocketMinipoolQueueInterface rocketMinipoolQueue = RocketMinipoolQueueInterface(getContractAddress("rocketMinipoolQueue"));
         // Setup initial variable values
-        uint256 balance = rocketVault.balanceOf("rocketDepositPool");
+        uint256 balance = _rocketVault.balanceOf("rocketDepositPool");
         uint256 totalEther = 0;
         // Calculate minipool assignments
-        uint256 maxAssignments = rocketDAOProtocolSettingsDeposit.getMaximumDepositAssignments();
+        uint256 maxAssignments = _rocketDAOProtocolSettingsDeposit.getMaximumDepositAssignments();
         MinipoolAssignment[] memory assignments = new MinipoolAssignment[](maxAssignments);
         MinipoolDeposit depositType = MinipoolDeposit.None;
         uint256 count = 0;
@@ -174,7 +176,7 @@ contract RocketDepositPool is RocketBase, RocketDepositPoolInterface, RocketVaul
         }
         if (totalEther > 0) {
             // Withdraw ETH from vault
-            rocketVault.withdrawEther(totalEther);
+            _rocketVault.withdrawEther(totalEther);
             // Perform assignments
             for (uint256 i = 0; i < maxAssignments; ++i) {
                 if (assignments[i].etherAssigned == 0) { break; }
@@ -202,9 +204,4 @@ contract RocketDepositPool is RocketBase, RocketDepositPoolInterface, RocketVaul
         // Emit excess withdrawn event
         emit ExcessWithdrawn(msg.sender, _amount, block.timestamp);
     }
-
-    // Returns the block that _address last deposited ether on
-    function getUserLastDepositBlock(address _address) override external view returns (uint256) {
-        return getUint(keccak256(abi.encodePacked("user.deposit.block", _address)));
-    }
 }

contracts/contract/minipool/RocketMinipoolFactory.sol

@@ -0,0 +1,67 @@
+pragma solidity 0.7.6;
+
+// SPDX-License-Identifier: GPL-3.0-only
+
+import "@openzeppelin/contracts/math/SafeMath.sol";
+
+import "./RocketMinipool.sol";
+import "../RocketBase.sol";
+import "../../types/MinipoolStatus.sol";
+import "../../types/MinipoolDeposit.sol";
+import "../../interface/dao/node/RocketDAONodeTrustedInterface.sol";
+import "../../interface/minipool/RocketMinipoolInterface.sol";
+import "../../interface/minipool/RocketMinipoolManagerInterface.sol";
+import "../../interface/minipool/RocketMinipoolQueueInterface.sol";
+import "../../interface/node/RocketNodeStakingInterface.sol";
+import "../../interface/util/AddressSetStorageInterface.sol";
+import "../../interface/node/RocketNodeManagerInterface.sol";
+import "../../interface/network/RocketNetworkPricesInterface.sol";
+import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsMinipoolInterface.sol";
+import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsNodeInterface.sol";
+import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsNodeInterface.sol";
+import "../../interface/minipool/RocketMinipoolFactoryInterface.sol";
+
+// Minipool creation, removal and management
+
+contract RocketMinipoolFactory is RocketBase, RocketMinipoolFactoryInterface {
+
+    // Libs
+    using SafeMath for uint;
+
+    // Construct
+    constructor(RocketStorageInterface _rocketStorageAddress) RocketBase(_rocketStorageAddress) {
+        version = 1;
+    }
+
+    // Returns the bytecode for RocketMinipool
+    function getMinipoolBytecode() override public pure returns (bytes memory) {
+        return type(RocketMinipool).creationCode;
+    }
+
+    // Performs a CREATE2 deployment of a minipool contract with given salt
+    function deployContract(address _nodeAddress, MinipoolDeposit _depositType, uint256 _salt) override external onlyLatestContract("rocketMinipoolFactory", address(this)) onlyLatestContract("rocketMinipoolManager", msg.sender) returns (address) {
+        // Construct deployment bytecode
+        bytes memory creationCode = getMinipoolBytecode();
+        bytes memory bytecode = abi.encodePacked(creationCode, abi.encode(rocketStorage, _nodeAddress, _depositType));
+        // Construct final salt
+        uint256 salt = uint256(keccak256(abi.encodePacked(_nodeAddress, _salt)));
+        // CREATE2 deployment
+        address contractAddress;
+        uint256 codeSize;
+        assembly {
+            contractAddress := create2(
+            0,
+            add(bytecode, 0x20),
+            mload(bytecode),
+            salt
+            )
+
+            codeSize := extcodesize(contractAddress)
+        }
+        // Ensure deployment was successful
+        require(codeSize > 0, "Contract creation failed");
+        // Return address
+        return contractAddress;
+    }
+
+}