feat: reregistration delay

src/RegistryCoordinator.sol

@@ -368,6 +368,7 @@ contract RegistryCoordinator is
             operator: operator, 
             quorumNumbers: quorumNumbers
         });
+        lastEjectionTimestamp[operator] = block.timestamp;
     }
 
     /*******************************************************************************
@@ -423,6 +424,16 @@ contract RegistryCoordinator is
         _setEjector(_ejector);
     }
 
+    /**
+     * @notice Sets the reregistration delay, which is the time an operator must wait after 
+     * ejection before registering for any quorum
+     * @param _reregistrationDelay the new reregistration delay
+     * @dev only callable by the owner
+     */
+    function setReregistrationDelay(uint256 _reregistrationDelay) external onlyOwner {
+        reregistrationDelay = _reregistrationDelay;
+    }
+
     /*******************************************************************************
                             INTERNAL FUNCTIONS
     *******************************************************************************/
@@ -457,6 +468,9 @@ contract RegistryCoordinator is
         require(quorumsToAdd.noBitsInCommon(currentBitmap), "RegistryCoordinator._registerOperator: operator already registered for some quorums being registered for");
         uint192 newBitmap = uint192(currentBitmap.plus(quorumsToAdd));
 
+        // Check that the operator can reregister if ejected
+        require(lastEjectionTimestamp[operator] + reregistrationDelay < block.timestamp, "RegistryCoordinator._registerOperator: operator cannot reregister yet");
+
         /**
          * Update operator's bitmap, socket, and status. Only update operatorInfo if needed:
          * if we're `REGISTERED`, the operatorId and status are already correct.

src/RegistryCoordinatorStorage.sol

@@ -64,6 +64,11 @@ abstract contract RegistryCoordinatorStorage is IRegistryCoordinator {
     /// @notice the address of the entity allowed to eject operators from the AVS
     address public ejector;
 
+    /// @notice the last timestamp an operator was ejected
+    mapping(address => uint256) public lastEjectionTimestamp;
+    /// @notice the delay before an operator can reregister after being ejected
+    uint256 public reregistrationDelay;
+
     constructor(
         IServiceManager _serviceManager,
         IStakeRegistry _stakeRegistry,
@@ -78,5 +83,5 @@ abstract contract RegistryCoordinatorStorage is IRegistryCoordinator {
 
     // storage gap for upgradeability
     // slither-disable-next-line shadowing-state
-    uint256[41] private __GAP;
+    uint256[39] private __GAP;
 }

test/integration/User.t.sol

@@ -117,6 +117,7 @@ contract User is Test {
     function registerOperator(bytes calldata quorums) public createSnapshot virtual returns (bytes32) {
         _log("registerOperator", quorums);
 
+        vm.warp(block.timestamp + 1);
         registryCoordinator.registerOperator({
             quorumNumbers: quorums,
             socket: NAME,
@@ -208,6 +209,7 @@ contract User is Test {
                 expiry: expiry
             });
 
+        vm.warp(block.timestamp + 1);
         registryCoordinator.registerOperatorWithChurn({
             quorumNumbers: allQuorums,
             socket: NAME,

test/unit/EjectionManagerUnit.t.sol

@@ -251,6 +251,8 @@ contract EjectionManagerUnitTests is MockAVSDeployer {
 
         testEjectOperators_MultipleOperatorInsideRatelimit();
 
+        vm.warp(block.timestamp + 1);
+
         _registerOperaters(operatorsToEject, stake);
 
         vm.warp(block.timestamp + ratelimitWindow);

test/unit/RegistryCoordinatorUnit.t.sol

@@ -988,6 +988,62 @@ contract RegistryCoordinatorUnitTests_DeregisterOperator_EjectOperator is Regist
         registryCoordinator._deregisterOperatorExternal(defaultOperator, incorrectQuorum);
     }
 
+    function test_reregisterOperator_revert_reregistrationDelay() public {
+        uint256 reregistrationDelay = 1 days;
+        cheats.warp(block.timestamp + reregistrationDelay);
+        cheats.prank(registryCoordinatorOwner);
+        registryCoordinator.setReregistrationDelay(reregistrationDelay);
+
+        ISignatureUtils.SignatureWithSaltAndExpiry memory emptySig;
+        uint32 registrationBlockNumber = 100;
+        uint32 reregistrationBlockNumber = 200;
+
+        bytes memory quorumNumbers = new bytes(1);
+        quorumNumbers[0] = bytes1(defaultQuorumNumber);
+
+        _setOperatorWeight(defaultOperator, uint8(quorumNumbers[0]), defaultStake);
+
+        cheats.prank(defaultOperator);
+        cheats.roll(registrationBlockNumber);
+        registryCoordinator.registerOperator(quorumNumbers, defaultSocket, pubkeyRegistrationParams, emptySig);
+
+        cheats.prank(ejector);
+        registryCoordinator.ejectOperator(defaultOperator, quorumNumbers);
+
+        cheats.prank(defaultOperator);
+        cheats.roll(reregistrationBlockNumber);
+        cheats.expectRevert("RegistryCoordinator._registerOperator: operator cannot reregister yet");
+        registryCoordinator.registerOperator(quorumNumbers, defaultSocket, pubkeyRegistrationParams, emptySig);
+    }
+
+    function test_reregisterOperator_reregistrationDelay() public {
+        uint256 reregistrationDelay = 1 days;
+        cheats.warp(block.timestamp + reregistrationDelay);
+        cheats.prank(registryCoordinatorOwner);
+        registryCoordinator.setReregistrationDelay(reregistrationDelay);
+
+        ISignatureUtils.SignatureWithSaltAndExpiry memory emptySig;
+        uint32 registrationBlockNumber = 100;
+        uint32 reregistrationBlockNumber = 200;
+
+        bytes memory quorumNumbers = new bytes(1);
+        quorumNumbers[0] = bytes1(defaultQuorumNumber);
+
+        _setOperatorWeight(defaultOperator, uint8(quorumNumbers[0]), defaultStake);
+
+        cheats.prank(defaultOperator);
+        cheats.roll(registrationBlockNumber);
+        registryCoordinator.registerOperator(quorumNumbers, defaultSocket, pubkeyRegistrationParams, emptySig);
+
+        cheats.prank(ejector);
+        registryCoordinator.ejectOperator(defaultOperator, quorumNumbers);
+
+        cheats.prank(defaultOperator);
+        cheats.roll(reregistrationBlockNumber);
+        cheats.warp(block.timestamp + reregistrationDelay + 1);
+        registryCoordinator.registerOperator(quorumNumbers, defaultSocket, pubkeyRegistrationParams, emptySig);
+    }
+
     // note: this is not possible to test, because there is no route to getting the operator registered for nonexistent quorums
     // function test_deregisterOperatorExternal_revert_nonexistentQuorums() public {