SD utility pool

contracts/OperatorRewardsCollector.sol

@@ -13,6 +13,9 @@ contract OperatorRewardsCollector is IOperatorRewardsCollector, AccessControlUpg
 
     mapping(address => uint256) public balances;
 
+    mapping(address => uint256)[] public owedAmounts;
+    mapping(address => uint256)[] public claimableAmounts;
+
     /// @custom:oz-upgrades-unsafe-allow constructor
     constructor() {
         _disableInitializers();
@@ -46,6 +49,30 @@ contract OperatorRewardsCollector is IOperatorRewardsCollector, AccessControlUpg
         emit Claimed(operatorRewardsAddr, amount);
     }
 
+    function claimFor(address operator) external {
+        uint256 toSendAmount;
+        for (uint256 i = 0; i < owedAmounts[operator].length; i++) {
+            if (balances[operator] >= owedAmounts[operator][i]) {
+                toSendAmount = owedAmounts[operator][i];
+                balances[operator] -= owedAmounts[operator][i];
+                claimableAmounts[operator][i] = owedAmounts[operator][i];
+                owedAmounts[operator][i] = 0;
+            } else {
+                toSendAmount = balances[operator];
+                owedAmounts[operator][i] -= balances[operator];
+                claimableAmounts[operator][i] = balances[operator];
+                balances[operator] = 0;
+                break;
+            }
+        }
+
+        if (balances[operator] > 0) {
+            address operatorRewardsAddr = UtilLib.getOperatorRewardAddress(operator, staderConfig);
+            UtilLib.sendValue(operatorRewardsAddr, balances[operator]);
+            emit Claimed(operatorRewardsAddr, balances[operator]);
+        }
+    }
+
     function updateStaderConfig(address _staderConfig) external onlyRole(DEFAULT_ADMIN_ROLE) {
         UtilLib.checkNonZeroAddress(_staderConfig);
         staderConfig = IStaderConfig(_staderConfig);

contracts/PermissionlessNodeRegistry.sol

@@ -8,6 +8,7 @@ import './interfaces/IStaderConfig.sol';
 import './interfaces/IVaultFactory.sol';
 import './interfaces/IPoolUtils.sol';
 import './interfaces/INodeRegistry.sol';
+import './interfaces/ISDUtilityPool.sol';
 import './interfaces/IPermissionlessPool.sol';
 import './interfaces/INodeELRewardVault.sol';
 import './interfaces/IStaderInsuranceFund.sol';
@@ -128,13 +129,29 @@ contract PermissionlessNodeRegistry is
         bytes[] calldata _preDepositSignature,
         bytes[] calldata _depositSignature
     ) external payable override nonReentrant whenNotPaused {
+        addValidatorKeysWithUtilizeSD(0, _pubkey, _preDepositSignature, _depositSignature);
+    }
+
+    /**
+     * @notice add validator keys
+     * @dev only accepts if bond of 4 ETH per key is provided along with sufficient SD lockup after utilize
+     * @param _amountOfSDToUtilize amount of SD to utilize from Utility Pool
+     * @param _pubkey pubkey of validators
+     * @param _preDepositSignature signature of a validators for 1ETH deposit
+     * @param _depositSignature signature of a validator for 31ETH deposit
+     */
+    function addValidatorKeysWithUtilizeSD(
+        uint256 _amountOfSDToUtilize,
+        bytes[] calldata _pubkey,
+        bytes[] calldata _preDepositSignature,
+        bytes[] calldata _depositSignature
+    ) public payable override nonReentrant whenNotPaused {
         uint256 operatorId = onlyActiveOperator(msg.sender);
-        (uint256 keyCount, uint256 operatorTotalKeys) = checkInputKeysCountAndCollateral(
-            _pubkey.length,
-            _preDepositSignature.length,
-            _depositSignature.length,
-            operatorId
-        );
+        uint256 keyCount = _pubkey.length;
+        if (keyCount != _preDepositSignature.length || keyCount != _depositSignature.length) {
+            revert MisMatchingInputKeysSize();
+        }
+        uint256 operatorTotalKeys = checkInputKeysCountAndCollateral(keyCount, operatorId, _amountOfSDToUtilize);
 
         address vaultFactory = staderConfig.getVaultFactory();
         address poolUtils = staderConfig.getPoolUtils();
@@ -662,15 +679,10 @@ contract PermissionlessNodeRegistry is
 
     // validate the input of `addValidatorKeys` function
     function checkInputKeysCountAndCollateral(
-        uint256 _pubkeyLength,
-        uint256 _preDepositSignatureLength,
-        uint256 _depositSignatureLength,
-        uint256 _operatorId
-    ) internal view returns (uint256 keyCount, uint256 totalKeys) {
-        if (_pubkeyLength != _preDepositSignatureLength || _pubkeyLength != _depositSignatureLength) {
-            revert MisMatchingInputKeysSize();
-        }
-        keyCount = _pubkeyLength;
+        uint256 keyCount,
+        uint256 _operatorId,
+        uint256 _amountOfSDToUtilize
+    ) internal returns (uint256 totalKeys) {
         if (keyCount == 0 || keyCount > inputKeyCountLimit) {
             revert InvalidKeyCount();
         }
@@ -685,6 +697,13 @@ contract PermissionlessNodeRegistry is
         if (msg.value != keyCount * COLLATERAL_ETH) {
             revert InvalidBondEthValue();
         }
+        if (_amountOfSDToUtilize > 0) {
+            ISDUtilityPool(staderConfig.getSDUtilityPool()).utilizeWhileAddingKeys(
+                msg.sender,
+                _amountOfSDToUtilize,
+                totalNonTerminalKeys + keyCount
+            );
+        }
         //checks if operator has enough SD collateral for adding `keyCount` keys
         if (
             !ISDCollateral(staderConfig.getSDCollateral()).hasEnoughSDCollateral(

contracts/SDCollateral.sol

@@ -7,6 +7,7 @@ import '../contracts/interfaces/IPoolUtils.sol';
 import '../contracts/interfaces/SDCollateral/ISDCollateral.sol';
 import '../contracts/interfaces/SDCollateral/IAuction.sol';
 import '../contracts/interfaces/IStaderOracle.sol';
+import './interfaces/ISDUtilityPool.sol';
 
 import '@openzeppelin/contracts/utils/math/Math.sol';
 import '@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol';
@@ -17,6 +18,8 @@ contract SDCollateral is ISDCollateral, AccessControlUpgradeable, ReentrancyGuar
     IStaderConfig public override staderConfig;
     mapping(uint8 => PoolThresholdInfo) public poolThresholdbyPoolId;
     mapping(address => uint256) public override operatorSDBalance;
+    //amount of SD added as collateral via utility pool
+    mapping(address => uint256) public override operatorUtilizedSDBalance;
 
     /// @custom:oz-upgrades-unsafe-allow constructor
     constructor() {
@@ -51,21 +54,67 @@ contract SDCollateral is ISDCollateral, AccessControlUpgradeable, ReentrancyGuar
         emit SDDeposited(operator, _sdAmount);
     }
 
+    function depositUtilizedSD(address _operator, uint256 _sdAmount) external override {
+        UtilLib.onlyStaderContract(msg.sender, staderConfig, staderConfig.SD_UTILITY_POOL());
+
+        operatorUtilizedSDBalance[_operator] += _sdAmount;
+        if (!IERC20(staderConfig.getStaderToken()).transferFrom(msg.sender, address(this), _sdAmount)) {
+            revert SDTransferFailed();
+        }
+
+        emit UtilizedSDDeposited(_operator, _sdAmount);
+    }
+
+    function reduceUtilizedSDPosition(address operator, uint256 sdAmount) external override {
+        UtilLib.onlyStaderContract(msg.sender, staderConfig, staderConfig.SD_UTILITY_POOL());
+
+        operatorUtilizedSDBalance[operator] -= sdAmount;
+        operatorSDBalance[operator] += sdAmount;
+
+        emit ReducedUtilizedPosition(operator, sdAmount);
+    }
+
     /// @notice for operator to withdraw their sd collateral, which is over and above withdraw threshold
     function withdraw(uint256 _requestedSD) external override {
         address operator = msg.sender;
-        uint256 opSDBalance = operatorSDBalance[operator];
+        uint256 operatorUtilizedSD = operatorUtilizedSDBalance[operator];
+        uint256 opSDBalance = operatorSDBalance[operator] + operatorUtilizedSD;
 
         if (opSDBalance < getOperatorWithdrawThreshold(operator) + _requestedSD) {
             revert InsufficientSDToWithdraw(opSDBalance);
         }
-        operatorSDBalance[operator] -= _requestedSD;
+        uint256 operatorCurrentUtilizeSD = ISDUtilityPool(staderConfig.getSDUtilityPool()).utilizerBalanceCurrent(
+            operator
+        );
 
-        // cannot use safeERC20 as this contract is an upgradeable contract, and using safeERC20 is not upgrade-safe
-        if (!IERC20(staderConfig.getStaderToken()).transfer(payable(operator), _requestedSD)) {
-            revert SDTransferFailed();
+        uint256 utilizePositionChange = operatorUtilizedSD >= _requestedSD ? _requestedSD : operatorUtilizedSD;
+        operatorUtilizedSDBalance[operator] -= utilizePositionChange;
+        uint256 remainingUtilizePosition = operatorCurrentUtilizeSD - utilizePositionChange;
+        uint256 selfBondedPositionChange = _requestedSD - utilizePositionChange;
+        uint256 repayFromSelfBond = remainingUtilizePosition >= selfBondedPositionChange
+            ? selfBondedPositionChange
+            : remainingUtilizePosition;
+        operatorSDBalance[operator] -= selfBondedPositionChange;
+
+        if (utilizePositionChange + repayFromSelfBond > 0) {
+            ISDUtilityPool(staderConfig.getSDUtilityPool()).repayViaSDCollateral(
+                operator,
+                utilizePositionChange + repayFromSelfBond
+            );
         }
-
+        if (selfBondedPositionChange - repayFromSelfBond > 0) {
+            address operatorRewardAddr = UtilLib.getOperatorRewardAddress(operator, staderConfig);
+            // cannot use safeERC20 as this contract is an upgradeable contract, and using safeERC20 is not upgrade-safe
+            if (
+                !IERC20(staderConfig.getStaderToken()).transfer(
+                    operatorRewardAddr,
+                    selfBondedPositionChange - repayFromSelfBond
+                )
+            ) {
+                revert SDTransferFailed();
+            }
+        }
+        emit SDRepaid(operator, utilizePositionChange + repayFromSelfBond);
         emit SDWithdrawn(operator, _requestedSD);
     }
 
@@ -85,22 +134,31 @@ contract SDCollateral is ISDCollateral, AccessControlUpgradeable, ReentrancyGuar
     /// @param _operator which operator SD collateral to slash
     /// @param _sdToSlash amount of SD to slash
     function slashSD(address _operator, uint256 _sdToSlash) internal {
-        uint256 sdBalance = operatorSDBalance[_operator];
+        uint256 operatorSelfBondedSD = operatorSDBalance[_operator];
+        uint256 sdBalance = operatorSelfBondedSD + operatorUtilizedSDBalance[_operator];
         uint256 sdSlashed = Math.min(_sdToSlash, sdBalance);
         if (sdSlashed == 0) {
             return;
         }
-        operatorSDBalance[_operator] -= sdSlashed;
+        uint256 sdSlashFromUtilized = operatorSelfBondedSD >= sdSlashed ? 0 : sdSlashed - operatorSelfBondedSD;
+        operatorSDBalance[_operator] -= (sdSlashed - sdSlashFromUtilized);
+        if (sdSlashFromUtilized > 0) {
+            operatorUtilizedSDBalance[_operator] -= sdSlashFromUtilized;
+        }
         IAuction(staderConfig.getAuctionContract()).createLot(sdSlashed);
+        emit SDSLashedFromUtilize(_operator, sdSlashFromUtilized);
         emit SDSlashed(_operator, staderConfig.getAuctionContract(), sdSlashed);
     }
 
-    /// @notice for max approval to auction contract for spending SD tokens
+    /// @notice for max approval to auction/SD utility pool contract for spending SD tokens
     function maxApproveSD() external override {
         UtilLib.onlyManagerRole(msg.sender, staderConfig);
         address auctionContract = staderConfig.getAuctionContract();
+        address sdUtilityPool = staderConfig.getSDUtilityPool();
         UtilLib.checkNonZeroAddress(auctionContract);
+        UtilLib.checkNonZeroAddress(sdUtilityPool);
         IERC20(staderConfig.getStaderToken()).approve(auctionContract, type(uint256).max);
+        IERC20(staderConfig.getStaderToken()).approve(sdUtilityPool, type(uint256).max);
     }
 
     // SETTERS
@@ -182,7 +240,7 @@ contract SDCollateral is ISDCollateral, AccessControlUpgradeable, ReentrancyGuar
         uint8 _poolId,
         uint256 _numValidator
     ) public view override returns (uint256) {
-        uint256 sdBalance = operatorSDBalance[_operator];
+        uint256 sdBalance = operatorSDBalance[_operator] + operatorUtilizedSDBalance[_operator];
         uint256 minSDToBond = getMinimumSDToBond(_poolId, _numValidator);
         return (sdBalance >= minSDToBond ? 0 : minSDToBond - sdBalance);
     }
@@ -195,7 +253,7 @@ contract SDCollateral is ISDCollateral, AccessControlUpgradeable, ReentrancyGuar
 
         uint256 totalMinThreshold = validatorCount * convertETHToSD(poolThreshold.minThreshold);
         uint256 totalMaxThreshold = validatorCount * convertETHToSD(poolThreshold.maxThreshold);
-        uint256 sdBalance = operatorSDBalance[_operator];
+        uint256 sdBalance = operatorSDBalance[_operator] + operatorUtilizedSDBalance[_operator];
         return (sdBalance < totalMinThreshold ? 0 : Math.min(sdBalance, totalMaxThreshold));
     }
 
@@ -212,7 +270,7 @@ contract SDCollateral is ISDCollateral, AccessControlUpgradeable, ReentrancyGuar
     // HELPER
 
     function getOperatorInfo(address _operator)
-        internal
+        public
         view
         returns (
             uint8 _poolId,

contracts/SDIncentiveController.sol

@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.16;
+
+import '@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol';
+import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+
+import './library/UtilLib.sol';
+import './interfaces/IStaderConfig.sol';
+import './interfaces/ISDUtilityPool.sol';
+import './interfaces/ISDIncentiveController.sol';
+
+/// @title SDIncentiveController
+/// @notice This contract handles the distribution of reward tokens for a lending pool.
+contract SDIncentiveController is ISDIncentiveController, AccessControlUpgradeable {
+    // The emission rate of the reward tokens per block.
+    uint256 public emissionPerBlock;
+
+    // The block number of the last reward calculation.
+    uint256 public lastUpdateBlockNumber;
+
+    // The stored value of the reward per token, used to calculate rewards.
+    uint256 public rewardPerTokenStored;
+
+    // Reference to the Stader configuration contract.
+    IStaderConfig public staderConfig;
+
+    // A mapping of accounts to their pending reward amounts.
+    mapping(address => uint256) public rewards;
+
+    // A mapping of accounts to the reward per token value at their last update.
+    mapping(address => uint256) public userRewardPerTokenPaid;
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    /// @notice Initializes the contract with necessary addresses.
+    /// @param _staderConfig The address of the Stader configuration contract.
+    function initialize(address _staderConfig) external initializer {
+        UtilLib.checkNonZeroAddress(_staderConfig);
+
+        staderConfig = IStaderConfig(_staderConfig);
+
+        __AccessControl_init();
+    }
+
+    /// @notice Claims the accrued rewards for an account.
+    /// @param account The address of the account claiming rewards.
+    function claim(address account) external {
+        UtilLib.onlyStaderContract(msg.sender, staderConfig, staderConfig.SD_UTILITY_POOL());
+
+        updateReward(account);
+
+        uint256 reward = rewards[account];
+        require(reward > 0, 'No rewards to claim.');
+        rewards[account] = 0;
+        IERC20(staderConfig.getStaderToken()).transfer(account, reward);
+
+        emit RewardClaimed(account, reward);
+    }
+
+    /// @notice Updates the reward on deposit in the lending pool.
+    /// @param account The account that made a deposit.
+    function onDelegate(address account) external override {
+        UtilLib.onlyStaderContract(msg.sender, staderConfig, staderConfig.SD_UTILITY_POOL());
+
+        updateReward(account);
+    }
+
+    /// @notice Calculates the current reward per token.
+    /// @return The calculated reward per token.
+    function rewardPerToken() public view returns (uint256) {
+        uint256 totalSupply = ISDUtilityPool(staderConfig.getSDUtilityPool()).cTokenTotalSupply();
+        if (totalSupply == 0) {
+            return rewardPerTokenStored;
+        }
+        return
+            rewardPerTokenStored + (((block.number - lastUpdateBlockNumber) * emissionPerBlock * 1e18) / totalSupply);
+    }
+
+    /// @notice Calculates the total accrued reward for an account.
+    /// @param account The account to calculate rewards for.
+    /// @return The total accrued reward for the account.
+    function earned(address account) public view returns (uint256) {
+        uint256 currentBalance = ISDUtilityPool(staderConfig.getSDUtilityPool()).delegatorCTokenBalance(account);
+        uint256 currentRewardPerToken = rewardPerToken();
+
+        return ((currentBalance * (currentRewardPerToken - userRewardPerTokenPaid[account])) / 1e18) + rewards[account];
+    }
+
+    /// @dev Internal function to update the reward state for an account.
+    /// @param account The account to update the reward for.
+    function updateReward(address account) internal {
+        rewardPerTokenStored = rewardPerToken();
+        lastUpdateBlockNumber = block.number;
+
+        if (account != address(0)) {
+            rewards[account] = earned(account);
+            userRewardPerTokenPaid[account] = rewardPerTokenStored;
+        }
+    }
+
+    /// @dev Emitted when a reward is claimed.
+    /// @param user The user who claimed the reward.
+    /// @param reward The amount of reward claimed.
+    event RewardClaimed(address indexed user, uint256 reward);
+}