SD utility pool

.gitignore

@@ -18,6 +18,7 @@ lcov.info
 # Foundry
 cache_forge/
 out/
+broadcast
 
 
 

README.md

@@ -1,4 +1,4 @@
 [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
 
 # Overview
 
@@ -56,3 +56,16 @@
 # Integration
 
 Check the Integration guide [here](https://github.com/stader-labs/ethx/blob/mainnet_V0/INTEGRATION.md)
+
+# Dependencies
+This project incorporates code from the following external sources:
+- Compound Labs, Inc. (licensed under the BSD-3-Clause License)
+
+- Ben Hauser (licensed under the MIT License)
+
+The borrowed code contributes to 'SDUtilityPool.sol for computing fee, utilizer balance and exchange rate for a C-token based model' and 'SDIncentiveController.sol for computing incentivize rewards to the delegator of UtilityPool' respectively. For further details on the specific code sections and their respective licenses, please refer to the Third-Party Licenses file.
+
+Link to Third-Party Licenses:
+
+[THIRD-PARTY-LICENSES.md](https://github.com/stader-labs/ethx/blob/mainnet_V0/THIRD-PARTY-LICENSES.md)
+

THIRD-PARTY-LICENSES.md

@@ -0,0 +1,82 @@
+                                        THIRD PARTY LICENSES
+
+Compound Code (BSD-3-Clause License)
+
+This project incorporates portions of code originally developed by Compound Labs, Inc. and 
+licensed under the BSD-3-Clause License ("BSD-3-Clause"). The full text of the BSD-3-Clause 
+License is included below for your reference:
+
+Copyright (c) 2020 Compound Labs, Inc.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted
+provided that the following conditions are met:
+
+- Redistributions of source code must retain the above copyright notice, this list of
+ conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright notice, this list of
+ conditions and the following disclaimer in the documentation and/or other materials
+  provided with the distribution.
+
+- Neither the name of the copyright holder nor the names of its contributors may be used
+ to endorse or promote products derived from this software without specific prior written
+  permission.
+
+
+DISCLAIMER:
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The following sections of this project codebase are derived from the Compound code:
+
+contracts/SDUtilityPool.sol -  accrueFee(), utilizerBalanceCurrent(address account), 
+utilizerBalanceStored(address account), _utilizerBalanceStoredInternal(address account), 
+exchangeRateCurrent(),exchangeRateStored(), _exchangeRateStored(). 
+
+These are the logic to compute the rewards, compute utilizer balance and
+exchangeRate computation for C-token based model.
+
+Curvefi Code (MIT License)
+
+This project incorporates portions of code originally developed by Ben Hauser and licensed
+under the MIT License. The full text of the MIT License is included below for your reference:
+
+MIT License
+
+Copyright (c) 2020 Ben Hauser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+and associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the Software is furnished to
+do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
+OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Specific Code Attribution:
+
+The following sections of this project codebase are derived from the Curvefi code:
+
+contracts/SDIncentiveController.sol - updateRewardForAccount(address account), 
+rewardPerToken() and earned(address account).
+
+These are mainly the logic for storing and computing user incentivize rewards.

contracts/OperatorRewardsCollector.sol

@@ -3,16 +3,26 @@ pragma solidity 0.8.16;
 
 import './library/UtilLib.sol';
 
+import './interfaces/INodeRegistry.sol';
+import './interfaces/INodeELRewardVault.sol';
+import './interfaces/IPermissionlessNodeRegistry.sol';
 import './interfaces/IOperatorRewardsCollector.sol';
 import './interfaces/IStaderConfig.sol';
+import './interfaces/ISDUtilityPool.sol';
+import './interfaces/SDCollateral/ISDCollateral.sol';
+import './interfaces/IWETH.sol';
+import '../contracts/interfaces/IStaderOracle.sol';
 
+import '@openzeppelin/contracts/utils/math/Math.sol';
 import '@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol';
 
 contract OperatorRewardsCollector is IOperatorRewardsCollector, AccessControlUpgradeable {
     IStaderConfig public staderConfig;
 
     mapping(address => uint256) public balances;
 
+    IWETH public weth;
+
     /// @custom:oz-upgrades-unsafe-allow constructor
     constructor() {
         _disableInitializers();
@@ -36,19 +46,169 @@ contract OperatorRewardsCollector is IOperatorRewardsCollector, AccessControlUpg
         emit DepositedFor(msg.sender, _receiver, msg.value);
     }
 
+    /**
+     * @notice Claims payouts for an operator, repaying any outstanding liquidations and transferring any remaining balance to the operator's rewards address.
+     * @dev This function first checks for any unpaid liquidations for the operator and repays them if necessary. Then, it transfers any remaining balance to the operator's reward address.
+     */
     function claim() external {
-        address operator = msg.sender;
-        uint256 amount = balances[operator];
-        balances[operator] -= amount;
+        claimLiquidation(msg.sender);
 
-        address operatorRewardsAddr = UtilLib.getOperatorRewardAddress(msg.sender, staderConfig);
-        UtilLib.sendValue(operatorRewardsAddr, amount);
-        emit Claimed(operatorRewardsAddr, amount);
+        uint256 amount = balances[msg.sender] > withdrawableInEth(msg.sender)
+            ? withdrawableInEth(msg.sender)
+            : balances[msg.sender];
+        _claim(msg.sender, amount);
+    }
+
+    /**
+     * @notice function to claim a given amount of ETH, this is done to make sure operator can claim
+     * any desired amount such that their health factor remains above 1
+     * @dev amount should not be more than the minimum of operator balance and withdrawableInEth after completing liquidation if any
+     * @param _amount amount of ETH to claim
+     */
+    function claimWithAmount(uint256 _amount) external {
+        claimLiquidation(msg.sender);
+        _claim(msg.sender, _amount);
+    }
+
+    function claimLiquidation(address operator) public override {
+        _transferBackUtilizedSD(operator);
+        _completeLiquidationIfExists(operator);
     }
 
     function updateStaderConfig(address _staderConfig) external onlyRole(DEFAULT_ADMIN_ROLE) {
         UtilLib.checkNonZeroAddress(_staderConfig);
         staderConfig = IStaderConfig(_staderConfig);
         emit UpdatedStaderConfig(_staderConfig);
     }
+
+    function withdrawableInEth(address operator) public view override returns (uint256) {
+        ISDUtilityPool sdUtilityPool = ISDUtilityPool(staderConfig.getSDUtilityPool());
+        uint256 liquidationThreshold = sdUtilityPool.getLiquidationThreshold();
+        UserData memory userData = sdUtilityPool.getUserData(operator);
+        uint256 totalInterestAdjusted = (userData.totalInterestSD * 100) / liquidationThreshold;
+        uint256 sdPriceInETH = IStaderOracle(staderConfig.getStaderOracle()).getSDPriceInETH();
+
+        uint256 totalInterestAdjustedInEth = Math.ceilDiv(
+            (totalInterestAdjusted * sdPriceInETH),
+            staderConfig.getDecimals()
+        );
+
+        if (totalInterestAdjustedInEth > userData.totalCollateralInEth) return 0;
+        uint256 withdrawableAmountInEth = userData.totalCollateralInEth - totalInterestAdjustedInEth;
+
+        OperatorLiquidation memory operatorLiquidation = sdUtilityPool.getOperatorLiquidation(operator);
+        return
+            withdrawableAmountInEth > operatorLiquidation.totalAmountInEth
+                ? withdrawableAmountInEth - operatorLiquidation.totalAmountInEth
+                : 0;
+    }
+
+    function updateWethAddress(address _weth) external onlyRole(DEFAULT_ADMIN_ROLE) {
+        UtilLib.checkNonZeroAddress(_weth);
+        weth = IWETH(_weth);
+        emit UpdatedWethAddress(_weth);
+    }
+
+    function getBalance(address operator) external view override returns (uint256) {
+        return balances[operator];
+    }
+
+    /**
+     * @notice Completes any pending liquidation for an operator if exists.
+     * @dev Internal function to handle liquidation completion.
+     * @param operator The operator whose liquidation needs to be checked.
+     */
+    function _completeLiquidationIfExists(address operator) internal {
+        // Retrieve operator liquidation details
+        ISDUtilityPool sdUtilityPool = ISDUtilityPool(staderConfig.getSDUtilityPool());
+        OperatorLiquidation memory operatorLiquidation = sdUtilityPool.getOperatorLiquidation(operator);
+
+        // If the liquidation is not repaid, check balance and then proceed with repayment
+        if (!operatorLiquidation.isRepaid && operatorLiquidation.totalAmountInEth > 0) {
+            (uint8 poolId, uint256 operatorId, uint256 nonTerminalKeys) = ISDCollateral(staderConfig.getSDCollateral())
+                .getOperatorInfo(operator);
+            // Ensure that the balance is sufficient
+            if (balances[operator] < operatorLiquidation.totalAmountInEth && nonTerminalKeys > 0) {
+                revert InsufficientBalance();
+            }
+            address permissionlessNodeRegistry = staderConfig.getPermissionlessNodeRegistry();
+            if (INodeRegistry(permissionlessNodeRegistry).POOL_ID() == poolId) {
+                address nodeELVault = IPermissionlessNodeRegistry(permissionlessNodeRegistry)
+                    .nodeELRewardVaultByOperatorId(operatorId);
+                if (nodeELVault.balance > 0) {
+                    INodeELRewardVault(nodeELVault).withdraw();
+                }
+            }
+            if (balances[operator] < operatorLiquidation.totalAmountInEth) {
+                uint256 wETHDeposit = Math.min(
+                    balances[operator],
+                    operatorLiquidation.totalAmountInEth - operatorLiquidation.totalFeeInEth
+                );
+
+                weth.deposit{value: wETHDeposit}();
+                if (weth.transferFrom(address(this), operatorLiquidation.liquidator, wETHDeposit) == false)
+                    revert WethTransferFailed();
+                balances[operator] -= wETHDeposit;
+
+                uint256 protocolFee = Math.min(operatorLiquidation.totalFeeInEth, balances[operator]);
+                UtilLib.sendValue(staderConfig.getStaderTreasury(), protocolFee);
+
+                balances[operator] -= protocolFee;
+                sdUtilityPool.completeLiquidation(operator);
+            } else {
+                // Transfer WETH to liquidator and ETH to treasury
+                weth.deposit{value: operatorLiquidation.totalAmountInEth - operatorLiquidation.totalFeeInEth}();
+                if (
+                    weth.transferFrom(
+                        address(this),
+                        operatorLiquidation.liquidator,
+                        operatorLiquidation.totalAmountInEth - operatorLiquidation.totalFeeInEth
+                    ) == false
+                ) revert WethTransferFailed();
+                UtilLib.sendValue(staderConfig.getStaderTreasury(), operatorLiquidation.totalFeeInEth);
+
+                sdUtilityPool.completeLiquidation(operator);
+                balances[operator] -= operatorLiquidation.totalAmountInEth;
+            }
+        }
+    }
+
+    /**
+     * @notice Internal function to claim a specified amount for an operator.
+     * @dev Deducts the amount from the operator's balance and transfers it to their rewards address.
+     *      It also checks if the claiming amount does not exceed the withdrawable limit or the operator's balance.
+     * @param operator The address of the operator claiming the amount.
+     * @param amount The amount to be claimed.
+     */
+    function _claim(address operator, uint256 amount) internal {
+        uint256 maxWithdrawableInEth = withdrawableInEth(operator);
+
+        if (amount > maxWithdrawableInEth || amount > balances[operator]) revert InsufficientBalance();
+
+        balances[operator] -= amount;
+
+        // If there's an amount to send, transfer it to the operator's rewards address
+        if (amount > 0) {
+            address rewardsAddress = UtilLib.getOperatorRewardAddress(operator, staderConfig);
+            UtilLib.sendValue(rewardsAddress, amount);
+            emit Claimed(rewardsAddress, amount);
+        }
+    }
+
+    /**
+     * When the operator has no remaining active keys, transfer back the utilized SD to the operator.
+     * @param operator The address of the operator whose utilized SD needs to be transferred back.
+     */
+    function _transferBackUtilizedSD(address operator) internal {
+        ISDCollateral sdCollateral = ISDCollateral(staderConfig.getSDCollateral());
+        (, , uint256 nonTerminalKeys) = sdCollateral.getOperatorInfo(operator);
+
+        uint256 operatorUtilizedSDBal = sdCollateral.operatorUtilizedSDBalance(operator);
+
+        // Only proceed if the operator has no non-terminal (active) keys left and nonZero utilizedSD Balance
+        if (nonTerminalKeys > 0 || (operatorUtilizedSDBal == 0)) return;
+
+        // transfer back the operator's utilized SD balance to SD Utility Pool
+        sdCollateral.transferBackUtilizedSD(operator);
+    }
 }