chore: resolve merge conflicts

Author: stevennevins

audits/Rewards v2 - SigmaPrime - Dec 2024.pdf

@@ -51,38 +51,49 @@ contract EjectionManager is OwnableUpgradeable, EjectionManagerStorage {
             uint32 ejectedOperators;
 
             bool ratelimitHit;
-            for (uint8 j = 0; j < operatorIds[i].length; ++j) {
-                uint256 operatorStake =
-                    stakeRegistry.getCurrentStake(operatorIds[i][j], quorumNumber);
-
-                //if caller is ejector enforce ratelimit
-                if (
-                    isEjector[msg.sender] && quorumEjectionParams[quorumNumber].rateLimitWindow > 0
-                        && stakeForEjection + operatorStake > amountEjectable
-                ) {
-                    stakeEjectedForQuorum[quorumNumber].push(
-                        StakeEjection({timestamp: block.timestamp, stakeEjected: stakeForEjection})
-                    );
-                    ratelimitHit = true;
-                    break;
-                }
+            if(amountEjectable > 0 || msg.sender == owner()){
+                for(uint8 j = 0; j < operatorIds[i].length; ++j) {
+                    uint256 operatorStake = stakeRegistry.getCurrentStake(operatorIds[i][j], quorumNumber);
+
+                    //if caller is ejector enforce ratelimit
+                    if(
+                        isEjector[msg.sender] &&
+                        quorumEjectionParams[quorumNumber].rateLimitWindow > 0 &&
+                        stakeForEjection + operatorStake > amountEjectable
+                    ){
+                        ratelimitHit = true;
+
+                        stakeForEjection += operatorStake;
+                        ++ejectedOperators;
+
+                        registryCoordinator.ejectOperator(
+                            registryCoordinator.getOperatorFromId(operatorIds[i][j]),
+                            abi.encodePacked(quorumNumber)
+                        );
 
-                stakeForEjection += operatorStake;
-                ++ejectedOperators;
+                        emit OperatorEjected(operatorIds[i][j], quorumNumber);
 
-                registryCoordinator.ejectOperator(
-                    registryCoordinator.getOperatorFromId(operatorIds[i][j]),
-                    abi.encodePacked(quorumNumber)
-                );
+                        break;
+                    }
 
-                emit OperatorEjected(operatorIds[i][j], quorumNumber);
+                    stakeForEjection += operatorStake;
+                    ++ejectedOperators;
+
+                    registryCoordinator.ejectOperator(
+                        registryCoordinator.getOperatorFromId(operatorIds[i][j]),
+                        abi.encodePacked(quorumNumber)
+                    );
+
+                    emit OperatorEjected(operatorIds[i][j], quorumNumber);
+                }
             }
 
             //record the stake ejected if ejector and ratelimit enforced
-            if (!ratelimitHit && isEjector[msg.sender]) {
-                stakeEjectedForQuorum[quorumNumber].push(
-                    StakeEjection({timestamp: block.timestamp, stakeEjected: stakeForEjection})
-                );
+            if(isEjector[msg.sender] && stakeForEjection > 0){
+                stakeEjectedForQuorum[quorumNumber].push(StakeEjection({
+                    timestamp: block.timestamp,
+                    stakeEjected: stakeForEjection
+                }));
             }
 
             emit QuorumEjection(ejectedOperators, ratelimitHit);
@@ -151,4 +162,4 @@ contract EjectionManager is OwnableUpgradeable, EjectionManagerStorage {
         }
         return totalEjectable - totalEjected;
     }
-}
+}

src/EjectionManager.sol

@@ -9,6 +9,8 @@ import {IStakeRegistry} from "./interfaces/IStakeRegistry.sol";
 import {IIndexRegistry} from "./interfaces/IIndexRegistry.sol";
 import {IServiceManager} from "./interfaces/IServiceManager.sol";
 import {IRegistryCoordinator} from "./interfaces/IRegistryCoordinator.sol";
+import {ISocketRegistry} from "./interfaces/ISocketRegistry.sol";
+
 
 import {BitmapUtils} from "./libraries/BitmapUtils.sol";
 import {SlashingRegistryCoordinator} from "./SlashingRegistryCoordinator.sol";
@@ -34,13 +36,15 @@ contract RegistryCoordinator is IRegistryCoordinator, SlashingRegistryCoordinato
         IStakeRegistry _stakeRegistry,
         IBLSApkRegistry _blsApkRegistry,
         IIndexRegistry _indexRegistry,
+        ISocketRegistry _socketRegistry,
         IAllocationManager _allocationManager,
         IPauserRegistry _pauserRegistry
     )
         SlashingRegistryCoordinator(
             _stakeRegistry,
             _blsApkRegistry,
             _indexRegistry,
+            _socketRegistry,
             _allocationManager,
             _pauserRegistry
         )

src/RegistryCoordinator.sol

@@ -2,6 +2,8 @@
 pragma solidity ^0.8.27;
 
 import {Initializable} from "@openzeppelin-upgrades/contracts/proxy/utils/Initializable.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import {ISignatureUtils} from "eigenlayer-contracts/src/contracts/interfaces/ISignatureUtils.sol";
 import {IAVSDirectory} from "eigenlayer-contracts/src/contracts/interfaces/IAVSDirectory.sol";
 import {IStrategy} from "eigenlayer-contracts/src/contracts/interfaces/IStrategy.sol";
@@ -30,6 +32,7 @@ import {LibMergeSort} from "./libraries/LibMergeSort.sol";
  * @author Layr Labs, Inc.
  */
 abstract contract ServiceManagerBase is ServiceManagerBaseStorage {
+    using SafeERC20 for IERC20;
     using BitmapUtils for *;
 
     uint256 public constant SLASHER_PROPOSAL_DELAY = 7 days;
@@ -141,26 +144,93 @@ abstract contract ServiceManagerBase is ServiceManagerBaseStorage {
      * @dev Strategies must be in ascending order of addresses to check for duplicates
      * @dev This function will revert if the `rewardsSubmission` is malformed,
      * e.g. if the `strategies` and `weights` arrays are of non-equal lengths
+     * @dev This function may fail to execute with a large number of submissions due to gas limits. Use a
+     * smaller array of submissions if necessary.
      */
     function createAVSRewardsSubmission(
         IRewardsCoordinator.RewardsSubmission[] calldata rewardsSubmissions
     ) public virtual onlyRewardsInitiator {
         for (uint256 i = 0; i < rewardsSubmissions.length; ++i) {
             // transfer token to ServiceManager and approve RewardsCoordinator to transfer again
             // in createAVSRewardsSubmission() call
-            rewardsSubmissions[i].token.transferFrom(
-                msg.sender, address(this), rewardsSubmissions[i].amount
+            rewardsSubmissions[i].token.safeTransferFrom(
+                msg.sender,
+                address(this),
+                rewardsSubmissions[i].amount
             );
-            uint256 allowance =
-                rewardsSubmissions[i].token.allowance(address(this), address(_rewardsCoordinator));
-            rewardsSubmissions[i].token.approve(
-                address(_rewardsCoordinator), rewardsSubmissions[i].amount + allowance
+            rewardsSubmissions[i].token.safeIncreaseAllowance(
+                address(_rewardsCoordinator),
+                rewardsSubmissions[i].amount
             );
         }
 
         _rewardsCoordinator.createAVSRewardsSubmission(rewardsSubmissions);
     }
 
+    /**
+     * @notice Creates a new operator-directed rewards submission, to be split amongst the operators and
+     * set of stakers delegated to operators who are registered to this `avs`.
+     * @param operatorDirectedRewardsSubmissions The operator-directed rewards submissions being created.
+     * @dev Only callable by the permissioned rewardsInitiator address
+     * @dev The duration of the `rewardsSubmission` cannot exceed `MAX_REWARDS_DURATION`
+     * @dev The tokens are sent to the `RewardsCoordinator` contract
+     * @dev This contract needs a token approval of sum of all `operatorRewards` in the `operatorDirectedRewardsSubmissions`, before calling this function.
+     * @dev Strategies must be in ascending order of addresses to check for duplicates
+     * @dev Operators must be in ascending order of addresses to check for duplicates.
+     * @dev This function will revert if the `operatorDirectedRewardsSubmissions` is malformed.
+     * @dev This function may fail to execute with a large number of submissions due to gas limits. Use a
+     * smaller array of submissions if necessary.
+     */
+    function createOperatorDirectedAVSRewardsSubmission(
+        IRewardsCoordinator.OperatorDirectedRewardsSubmission[]
+            calldata operatorDirectedRewardsSubmissions
+    ) public virtual onlyRewardsInitiator {
+        for (
+            uint256 i = 0;
+            i < operatorDirectedRewardsSubmissions.length;
+            ++i
+        ) {
+            // Calculate total amount of token to transfer
+            uint256 totalAmount = 0;
+            for (
+                uint256 j = 0;
+                j <
+                operatorDirectedRewardsSubmissions[i].operatorRewards.length;
+                ++j
+            ) {
+                totalAmount += operatorDirectedRewardsSubmissions[i]
+                    .operatorRewards[j]
+                    .amount;
+            }
+
+            // Transfer token to ServiceManager and approve RewardsCoordinator to transfer again
+            // in createOperatorDirectedAVSRewardsSubmission() call
+            operatorDirectedRewardsSubmissions[i].token.safeTransferFrom(
+                msg.sender,
+                address(this),
+                totalAmount
+            );
+            operatorDirectedRewardsSubmissions[i].token.safeIncreaseAllowance(
+                address(_rewardsCoordinator),
+                totalAmount
+            );
+        }
+
+        _rewardsCoordinator.createOperatorDirectedAVSRewardsSubmission(
+            address(this),
+            operatorDirectedRewardsSubmissions
+        );
+    }
+
+    /**
+     * @notice Forwards a call to Eigenlayer's RewardsCoordinator contract to set the address of the entity that can call `processClaim` on behalf of this contract.
+     * @param claimer The address of the entity that can call `processClaim` on behalf of the earner
+     * @dev Only callable by the owner.
+     */
+    function setClaimerFor(address claimer) public virtual onlyOwner {
+        _rewardsCoordinator.setClaimerFor(claimer);
+    }
+
     /**
      * @notice Forwards a call to EigenLayer's AVSDirectory contract to confirm operator registration with the AVS
      * @param operator The address of the operator to register.
@@ -219,7 +289,12 @@ abstract contract ServiceManagerBase is ServiceManagerBaseStorage {
      * @dev No guarantee is made on uniqueness of each element in the returned array.
      *      The off-chain service should do that validation separately
      */
-    function getRestakeableStrategies() external view virtual returns (address[] memory) {
+    function getRestakeableStrategies()
+        external
+        view
+        virtual
+        returns (address[] memory)
+    {
         uint256 quorumCount = _registryCoordinator.quorumCount();
 
         if (quorumCount == 0) {
@@ -234,10 +309,13 @@ abstract contract ServiceManagerBase is ServiceManagerBaseStorage {
         address[] memory restakedStrategies = new address[](strategyCount);
         uint256 index = 0;
         for (uint256 i = 0; i < _registryCoordinator.quorumCount(); i++) {
-            uint256 strategyParamsLength = _stakeRegistry.strategyParamsLength(uint8(i));
+            uint256 strategyParamsLength = _stakeRegistry.strategyParamsLength(
+                uint8(i)
+            );
             for (uint256 j = 0; j < strategyParamsLength; j++) {
-                restakedStrategies[index] =
-                    address(_stakeRegistry.strategyParamsByIndex(uint8(i), j).strategy);
+                restakedStrategies[index] = address(
+                    _stakeRegistry.strategyParamsByIndex(uint8(i), j).strategy
+                );
                 index++;
             }
         }
@@ -255,28 +333,37 @@ abstract contract ServiceManagerBase is ServiceManagerBaseStorage {
         address operator
     ) external view virtual returns (address[] memory) {
         bytes32 operatorId = _registryCoordinator.getOperatorId(operator);
-        uint192 operatorBitmap = _registryCoordinator.getCurrentQuorumBitmap(operatorId);
+        uint192 operatorBitmap = _registryCoordinator.getCurrentQuorumBitmap(
+            operatorId
+        );
 
         if (operatorBitmap == 0 || _registryCoordinator.quorumCount() == 0) {
             return new address[](0);
         }
 
         // Get number of strategies for each quorum in operator bitmap
-        bytes memory operatorRestakedQuorums = BitmapUtils.bitmapToBytesArray(operatorBitmap);
+        bytes memory operatorRestakedQuorums = BitmapUtils.bitmapToBytesArray(
+            operatorBitmap
+        );
         uint256 strategyCount;
         for (uint256 i = 0; i < operatorRestakedQuorums.length; i++) {
-            strategyCount += _stakeRegistry.strategyParamsLength(uint8(operatorRestakedQuorums[i]));
+            strategyCount += _stakeRegistry.strategyParamsLength(
+                uint8(operatorRestakedQuorums[i])
+            );
         }
 
         // Get strategies for each quorum in operator bitmap
         address[] memory restakedStrategies = new address[](strategyCount);
         uint256 index = 0;
         for (uint256 i = 0; i < operatorRestakedQuorums.length; i++) {
             uint8 quorum = uint8(operatorRestakedQuorums[i]);
-            uint256 strategyParamsLength = _stakeRegistry.strategyParamsLength(quorum);
+            uint256 strategyParamsLength = _stakeRegistry.strategyParamsLength(
+                quorum
+            );
             for (uint256 j = 0; j < strategyParamsLength; j++) {
-                restakedStrategies[index] =
-                    address(_stakeRegistry.strategyParamsByIndex(quorum, j).strategy);
+                restakedStrategies[index] = address(
+                    _stakeRegistry.strategyParamsByIndex(quorum, j).strategy
+                );
                 index++;
             }
         }

src/ServiceManagerBase.sol

@@ -14,6 +14,8 @@ import {IBLSApkRegistry, IBLSApkRegistryTypes} from "./interfaces/IBLSApkRegistr
 import {IStakeRegistry, IStakeRegistryTypes} from "./interfaces/IStakeRegistry.sol";
 import {IIndexRegistry} from "./interfaces/IIndexRegistry.sol";
 import {ISlashingRegistryCoordinator} from "./interfaces/ISlashingRegistryCoordinator.sol";
+import {ISocketRegistry} from "./interfaces/ISocketRegistry.sol";
+
 
 import {BitmapUtils} from "./libraries/BitmapUtils.sol";
 import {BN254} from "./libraries/BN254.sol";
@@ -69,13 +71,15 @@ contract SlashingRegistryCoordinator is
         IStakeRegistry _stakeRegistry,
         IBLSApkRegistry _blsApkRegistry,
         IIndexRegistry _indexRegistry,
+        ISocketRegistry _socketRegistry,
         IAllocationManager _allocationManager,
         IPauserRegistry _pauserRegistry
     )
         SlashingRegistryCoordinatorStorage(
             _stakeRegistry,
             _blsApkRegistry,
             _indexRegistry,
+            _socketRegistry,
             _allocationManager
         )
         EIP712("AVSRegistryCoordinator", "v0.0.1")
@@ -337,11 +341,9 @@ contract SlashingRegistryCoordinator is
      * @notice Updates the socket of the msg.sender given they are a registered operator
      * @param socket is the new socket of the operator
      */
-    function updateSocket(
-        string memory socket
-    ) external {
+    function updateSocket(string memory socket) external {
         require(_operatorInfo[msg.sender].status == OperatorStatus.REGISTERED, NotRegistered());
-        emit OperatorSocketUpdate(_operatorInfo[msg.sender].operatorId, socket);
+        _setOperatorSocket(_operatorInfo[msg.sender].operatorId, socket);
     }
 
     /**
@@ -773,6 +775,17 @@ contract SlashingRegistryCoordinator is
         return totalStake * setParams.kickBIPsOfTotalStake / BIPS_DENOMINATOR;
     }
 
+    /**
+     * @notice Updates an operator's socket address in the SocketRegistry
+     * @param operatorId The unique identifier of the operator
+     * @param socket The new socket address to set for the operator
+     * @dev Emits an OperatorSocketUpdate event after updating
+     */
+    function _setOperatorSocket(bytes32 operatorId, string memory socket) internal {
+        socketRegistry.setOperatorSocket(operatorId, socket);
+        emit OperatorSocketUpdate(operatorId, socket);
+    }
+
     /// @notice verifies churnApprover's signature on operator churn approval and increments the churnApprover nonce
     function _verifyChurnApproverSignature(
         address registeringOperator,

src/SlashingRegistryCoordinator.sol

@@ -12,6 +12,7 @@ import {
     IAllocationManagerTypes
 } from "eigenlayer-contracts/src/contracts/interfaces/IAllocationManager.sol";
 import {ISlashingRegistryCoordinator} from "./interfaces/ISlashingRegistryCoordinator.sol";
+import {ISocketRegistry} from "./interfaces/ISocketRegistry.sol";
 
 abstract contract SlashingRegistryCoordinatorStorage is ISlashingRegistryCoordinator {
     /**
@@ -40,6 +41,8 @@ abstract contract SlashingRegistryCoordinatorStorage is ISlashingRegistryCoordin
     /// @notice The maximum number of quorums this contract supports
     uint8 internal constant MAX_QUORUM_COUNT = 192;
 
+    /// @notice
+    ISocketRegistry public immutable socketRegistry;
     /// @notice the BLS Aggregate Pubkey Registry contract that will keep track of operators' aggregate BLS public keys per quorum
     IBLSApkRegistry public immutable blsApkRegistry;
     /// @notice the Stake Registry contract that will keep track of operators' stakes
@@ -103,11 +106,13 @@ abstract contract SlashingRegistryCoordinatorStorage is ISlashingRegistryCoordin
         IStakeRegistry _stakeRegistry,
         IBLSApkRegistry _blsApkRegistry,
         IIndexRegistry _indexRegistry,
+        ISocketRegistry _socketRegistry,
         IAllocationManager _allocationManager
     ) {
         stakeRegistry = _stakeRegistry;
         blsApkRegistry = _blsApkRegistry;
         indexRegistry = _indexRegistry;
+        socketRegistry = _socketRegistry;
         allocationManager = _allocationManager;
     }