feat: instant alloc delay from dm (#1646)

**Motivation:**

Newly created operators in core have to wait 17.5 days to begin
allocating. This is a UX painpoint for new AVSs to onboard their
operators.

**Modifications:**

Update the `AllocationManager` so that the allocation delay for a newly
created operator is active immediately block. This allows operators to
make an allocation at the very next block.

**Result:**

Easier onboarding

Author: ypatil12

docs/core/AllocationManager.md

@@ -837,6 +837,9 @@ Once slashing is processed for a strategy, [slashed stake is burned or redistrib
  * allocating magnitude to an operator set, and the magnitude becoming slashable.
  * @param operator The operator to set the delay on behalf of.
  * @param delay the allocation delay in blocks
+ * @dev When the delay is set for a newly-registered operator (via the `DelegationManager.registerAsOperator` method),
+ * the delay will take effect immediately, allowing for operators to allocate slashable stake immediately. 
+ * Else, the delay will take effect after `ALLOCATION_CONFIGURATION_DELAY` blocks.
  */
 function setAllocationDelay(
     address operator,
@@ -847,15 +850,16 @@ function setAllocationDelay(
 
 _Note: IF NOT CALLED BY THE `DelegationManager`, this method can be called directly by an operator, or by a caller authorized by the operator. See [`PermissionController.md`](../permissions/PermissionController.md) for details._
 
-This function sets an operator's allocation delay, in blocks. This delay can be updated by the operator once set. Both the initial setting of this value and any further updates _take `ALLOCATION_CONFIGURATION_DELAY` blocks_ to take effect. Because having a delay is a requirement to allocating slashable stake, this effectively means that once the slashing release goes live, no one will be able to allocate slashable stake for at least `ALLOCATION_CONFIGURATION_DELAY` blocks.
+This function sets an operator's allocation delay, in blocks. This delay can be updated by the operator once set. The initial setting of this value by a newly created operator via [`DelegationManager.registerAsOperator`](./DelegationManager.md#registerasoperator) will take 1 block to take effect. The setting of this value for an operator who has already been registered in core or further updates _take `ALLOCATION_CONFIGURATION_DELAY` blocks_ to take effect. Because having a delay is a requirement to allocating slashable stake, this effectively means that once the slashing release goes live, no already-created operators will be able to allocate slashable stake for at least `ALLOCATION_CONFIGURATION_DELAY` blocks.
 
 The `DelegationManager` calls this upon operator registration for all new operators created after the slashing release. For operators that existed in the `DelegationManager` _prior_ to the slashing release, **they will need to call this method to configure an allocation delay prior to allocating slashable stake to any AVS**.
 
 The allocation delay's primary purpose is to give stakers delegated to an operator the chance to withdraw their stake before the operator can change the risk profile to something they're not comfortable with. However, operators can choose to configure this delay however they want - including setting it to 0.
 
 *Effects*:
 * Sets the operator's `pendingDelay` to the proposed `delay`, and save the `effectBlock` at which the `pendingDelay` can be activated
-    * `effectBlock = uint32(block.number) + ALLOCATION_CONFIGURATION_DELAY + 1`
+    * If a newly registered operator in core, `effectBlock = uint32(block.number)`, allowing operators to allocate slashable stake immediately after registration
+    * Else, `effectBlock = uint32(block.number) + ALLOCATION_CONFIGURATION_DELAY + 1`
 * If the operator has a `pendingDelay`, and if the `effectBlock` has passed, sets the operator's `delay` to the `pendingDelay` value
     * This also sets the `isSet` boolean to `true` to indicate that the operator's `delay`, even if 0, was set intentionally
 * Emits an `AllocationDelaySet` event

docs/core/DelegationManager.md

@@ -96,7 +96,7 @@ function registerAsOperator(
 
 Registers the caller as an operator in EigenLayer. The new operator provides the following input parameters:
 * `address initDelegationApprover`: *(OPTIONAL)* if set to a non-zero address, this address must sign and approve new delegation from stakers to this operator (See [`delegateTo`](#delegateto))
-* `uint32 allocationDelay`: the delay (in blocks) before slashable stake allocations will take effect. This is passed to the `AllocationManager` (See [`AllocationManager.md#setAllocationDelay`](./AllocationManager.md#setallocationdelay))
+* `uint32 allocationDelay`: the delay (in blocks) before slashable stake allocations will take effect. This is passed to the `AllocationManager` (See [`AllocationManager.md#setAllocationDelay`](./AllocationManager.md#setallocationdelay)). Upon registration, this allocation delay is effective immediately. Further modifications directly via `AllocationManager.setAllocationDelay` take `ALLOCATION_CONFIGURATION_DELAY` blocks.
 * `string calldata metadataURI`: emits this input in the event `OperatorMetadataURIUpdated`. Does not store the value anywhere.
 
 `registerAsOperator` cements the operator's delegation approver and allocation delay in storage, and self-delegates the operator to themselves - permanently marking the caller as an operator. They cannot "deregister" as an operator - however, if they have deposited funds, they can still withdraw them (See [Delegation and Withdrawals](#delegation-and-withdrawals)).

src/contracts/core/AllocationManager.sol

@@ -237,11 +237,17 @@ contract AllocationManager is
 
     /// @inheritdoc IAllocationManager
     function setAllocationDelay(address operator, uint32 delay) external {
-        if (msg.sender != address(delegation)) {
+        /// If the caller is the delegationManager, the operator is newly registered
+        /// This results in *newly-registered* operators in the core protocol to have their allocation delay effective immediately
+        bool newlyRegistered = (msg.sender == address(delegation));
+
+        // If we're not newly registered, check that the caller (not the delegationManager) is authorized to set the allocation delay for the operator
+        if (!newlyRegistered) {
             require(_checkCanCall(operator), InvalidCaller());
             require(delegation.isOperator(operator), InvalidOperator());
         }
-        _setAllocationDelay(operator, delay);
+
+        _setAllocationDelay(operator, delay, newlyRegistered);
     }
 
     /// @inheritdoc IAllocationManager
@@ -503,8 +509,9 @@ contract AllocationManager is
      * allocating magnitude to an operator set, and the magnitude becoming slashable.
      * @param operator The operator to set the delay on behalf of.
      * @param delay The allocation delay in blocks.
+     * @param newlyRegistered Whether the operator is newly registered in the core protocol.
      */
-    function _setAllocationDelay(address operator, uint32 delay) internal {
+    function _setAllocationDelay(address operator, uint32 delay, bool newlyRegistered) internal {
         AllocationDelayInfo memory info = _allocationDelayInfo[operator];
 
         // If there is a pending delay that can be applied now, set it
@@ -514,7 +521,16 @@ contract AllocationManager is
         }
 
         info.pendingDelay = delay;
-        info.effectBlock = uint32(block.number) + ALLOCATION_CONFIGURATION_DELAY + 1;
+
+        /// If the caller is the delegationManager, the operator is newly registered
+        /// This results in *newly-registered* operators in the core protocol to have their allocation delay effective immediately
+        if (newlyRegistered) {
+            // The delay takes effect immediately
+            info.effectBlock = uint32(block.number);
+        } else {
+            // Wait the entire configuration delay before the delay takes effect
+            info.effectBlock = uint32(block.number) + ALLOCATION_CONFIGURATION_DELAY + 1;
+        }
 
         _allocationDelayInfo[operator] = info;
         emit AllocationDelaySet(operator, delay, info.effectBlock);

src/contracts/interfaces/IAllocationManager.sol

@@ -315,6 +315,9 @@ interface IAllocationManager is IAllocationManagerErrors, IAllocationManagerEven
      * allocating magnitude to an operator set, and the magnitude becoming slashable.
      * @param operator The operator to set the delay on behalf of.
      * @param delay the allocation delay in blocks
+     * @dev When the delay is set for a newly-registered operator (via the `DelegationManager.registerAsOperator` method),
+     * the delay will take effect immediately, allowing for operators to allocate slashable stake immediately.
+     * Else, the delay will take effect after `ALLOCATION_CONFIGURATION_DELAY` blocks.
      */
     function setAllocationDelay(address operator, uint32 delay) external;
 

src/test/integration/IntegrationBase.t.sol

@@ -86,8 +86,6 @@ abstract contract IntegrationBase is IntegrationDeployer, TypeImporter {
         /// Registration flow is the same pre and post redistribution upgrade
         operator.registerAsOperator();
 
-        rollForward({blocks: ALLOCATION_CONFIGURATION_DELAY + 1});
-
         assert_Snap_Added_OperatorShares(operator, strategies, addedShares, "_newRandomOperator: failed to award shares to operator");
         assertTrue(delegationManager.isOperator(address(operator)), "_newRandomOperator: operator should be registered");
         assertEq(delegationManager.delegatedTo(address(operator)), address(operator), "_newRandomOperator: should be self-delegated");
@@ -101,8 +99,6 @@ abstract contract IntegrationBase is IntegrationDeployer, TypeImporter {
         /// Registration flow is the same pre and post redistribution upgrade
         operator.registerAsOperator();
 
-        rollForward({blocks: ALLOCATION_CONFIGURATION_DELAY + 1});
-
         assertTrue(delegationManager.isOperator(address(operator)), "_newRandomOperator: operator should be registered");
         assertEq(delegationManager.delegatedTo(address(operator)), address(operator), "_newRandomOperator: should be self-delegated");
         return operator;

src/test/integration/tests/upgrade/Redistribution.t.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.27;
+
+import "src/test/integration/UpgradeTest.t.sol";
+
+contract Integration_Upgrade_ZeroRegistrationDelay is UpgradeTest {
+    User operator;
+    User operator2;
+
+    AVS avs;
+    IStrategy[] strategies;
+    OperatorSet operatorSet;
+
+    function _init() internal override {
+        (, strategies,) = _newRandomStaker();
+        (avs,) = _newRandomAVS();
+        operatorSet = avs.createOperatorSet(strategies);
+    }
+
+    function testFuzz_register_upgrade_registerNew(uint24 r) public rand(r) {
+        // 1. Register operator
+        operator = _newRandomOperator_NoAssets();
+
+        (bool isSetOperator1,) = allocationManager.getAllocationDelay(address(operator));
+        // The delay should not be set since we adjusted `_newRandomOperator` to roll forward only 1 block after registration
+        assertFalse(isSetOperator1, "isSet should be false");
+
+        // 2. Upgrade contracts
+        _upgradeEigenLayerContracts();
+
+        // 3. Register new operator
+        operator2 = _newRandomOperator_NoAssets();
+        (bool isSetOperator2,) = allocationManager.getAllocationDelay(address(operator2));
+
+        // The delay should be set immediately
+        assertTrue(isSetOperator2, "isSet should be true");
+
+        // The delay for operator1 should still not be set
+        (isSetOperator1,) = allocationManager.getAllocationDelay(address(operator));
+        assertFalse(isSetOperator1, "isSet should be false");
+
+        // 4. Assert that operator2 is set after the configuration delay
+        rollForward({blocks: ALLOCATION_CONFIGURATION_DELAY + 1});
+        (isSetOperator1,) = allocationManager.getAllocationDelay(address(operator));
+        assertTrue(isSetOperator1, "isSet should be true");
+    }
+}

src/test/integration/tests/upgrade/ZeroRegistrationDelay.t.sol

@@ -3388,8 +3388,7 @@ contract AllocationManagerUnitTests_SetAllocationDelay is AllocationManagerUnitT
         cheats.prank(address(delegationManagerMock));
         allocationManager.setAllocationDelay(operatorToSet, delay);
 
-        // Warp to effect block
-        cheats.roll(block.number + ALLOCATION_CONFIGURATION_DELAY + 1);
+        // The allocation delay is set immediately
         (bool isSet, uint32 returnedDelay) = allocationManager.getAllocationDelay(operatorToSet);
         assertTrue(isSet, "isSet should be set");
         assertEq(delay, returnedDelay, "delay not set");