refactor: Enhance PriorityWithdrawalQueue for improved withdrawal request handling

- Update WithdrawRequest structure to include amountLocked for better tracking of finalized requests
- Modify fulfillRequests function to handle locking amounts and finalize requests correctly
- Adjust invalidateRequests to support both pending and finalized requests
- Update tests to reflect changes in request handling and ensure proper functionality

Author: pankajjagtapp

src/PriorityWithdrawalQueue.sol

@@ -99,7 +99,16 @@ contract PriorityWithdrawalQueue is
         uint32 creationTime
     );
     event WithdrawRequestCancelled(bytes32 indexed requestId, address indexed user, uint96 amountOfEEth, uint96 sharesOfEEth, uint32 nonce, uint32 timestamp);
-    event WithdrawRequestFinalized(bytes32 indexed requestId, address indexed user, uint96 amountOfEEth, uint96 sharesOfEEth, uint32 nonce, uint32 timestamp);
+    event WithdrawRequestFinalized(
+        bytes32 indexed pendingRequestId,
+        bytes32 indexed finalizedRequestId,
+        address indexed user,
+        uint96 amountOfEEth,
+        uint96 shareOfEEth,
+        uint32 nonce,
+        uint32 creationTime,
+        uint96 amountLocked
+    );
     event WithdrawRequestClaimed(bytes32 indexed requestId, address indexed user, uint96 amountOfEEth, uint96 sharesOfEEth, uint32 nonce, uint32 timestamp);
     event WithdrawRequestInvalidated(bytes32 indexed requestId, uint96 amountOfEEth, uint96 sharesOfEEth, uint32 nonce, uint32 timestamp);
     event WhitelistUpdated(address indexed user, bool status);
@@ -275,31 +284,62 @@ contract PriorityWithdrawalQueue is
 
     /// @notice Request manager finalizes withdrawal requests after maturity
     /// @dev Checks maturity and deadline, marks requests as finalized
-    /// @param requests Array of requests to finalize
+    ///      Pending requests have amountLocked=0, must pass such requests to this function
+    /// @param requests Array of pending requests to finalize (with amountLocked=0)
     function fulfillRequests(WithdrawRequest[] calldata requests) external onlyRequestManager whenNotPaused {
-        uint256 totalSharesToFinalize = 0;
+        uint256 totalAmountToLock = 0;
 
         for (uint256 i = 0; i < requests.length; ++i) {
             WithdrawRequest calldata request = requests[i];
             bytes32 requestId = keccak256(abi.encode(request));
 
+            // Pending requests must have amountLocked = 0
+            if (request.amountLocked != 0) revert BadInput();
+            
             // Verify request exists in pending set
             if (!_withdrawRequests.contains(requestId)) revert RequestNotFound();
-            if (_finalizedRequests.contains(requestId)) revert RequestAlreadyFinalized();
 
             // Check MIN_DELAY has passed (request must wait at least MIN_DELAY seconds)
             uint256 earliestFulfillTime = request.creationTime + MIN_DELAY;
             if (block.timestamp < earliestFulfillTime) revert NotMatured();
 
-            // Add to finalized set
-            _finalizedRequests.add(requestId);
-            totalSharesToFinalize += request.shareOfEEth;
-
-            emit WithdrawRequestFinalized(requestId, request.user, request.amountOfEEth, request.shareOfEEth, request.nonce, uint32(block.timestamp));
+            // Calculate and store the locked amount for this request
+            // Cap at original amount to prevent locking more than user requested
+            uint256 amountForShares = liquidityPool.amountForShare(request.shareOfEEth);
+            uint96 amountToLock = request.amountOfEEth < amountForShares 
+                ? request.amountOfEEth 
+                : uint96(amountForShares);
+            totalAmountToLock += amountToLock;
+
+            // Create finalized request with amountLocked set
+            bytes32 finalizedRequestId = keccak256(abi.encode(WithdrawRequest({
+                user: request.user,
+                amountOfEEth: request.amountOfEEth,
+                shareOfEEth: request.shareOfEEth,
+                nonce: request.nonce,
+                creationTime: request.creationTime,
+                amountLocked: amountToLock
+            })));
+
+            // Remove from pending set, add finalized request to finalized set
+            _withdrawRequests.remove(requestId);
+            
+            bool addedToFinalized = _finalizedRequests.add(finalizedRequestId);
+            if (!addedToFinalized) revert RequestAlreadyFinalized();
+            
+            emit WithdrawRequestFinalized(
+                requestId,
+                finalizedRequestId,
+                request.user,
+                request.amountOfEEth,
+                request.shareOfEEth,
+                request.nonce,
+                request.creationTime,
+                amountToLock
+            );
         }
 
         // Lock ETH in LiquidityPool for priority withdrawals
-        uint256 totalAmountToLock = liquidityPool.amountForShare(totalSharesToFinalize);
         liquidityPool.addEthAmountLockedForPriorityWithdrawal(uint128(totalAmountToLock));
     }
 
@@ -337,14 +377,18 @@ contract PriorityWithdrawalQueue is
         }
     }
 
-    /// @notice Invalidate a withdrawal request (prevents finalization)
+    /// @notice Invalidate withdrawal requests (can be pending or finalized)
     /// @param requests Array of requests to invalidate
     /// @return invalidatedRequestIds Array of request IDs that were invalidated
     function invalidateRequests(WithdrawRequest[] calldata requests) external onlyRequestManager returns (bytes32[] memory invalidatedRequestIds) {
         invalidatedRequestIds = new bytes32[](requests.length);
         for (uint256 i = 0; i < requests.length; ++i) {
             bytes32 requestId = keccak256(abi.encode(requests[i]));
-            if (!_withdrawRequests.contains(requestId)) revert RequestNotFound();
+            
+            // Verify request exists (either in pending or finalized set based on amountLocked)
+            bool isPending = requests[i].amountLocked == 0 && _withdrawRequests.contains(requestId);
+            bool isFinalized = requests[i].amountLocked > 0 && _finalizedRequests.contains(requestId);
+            if (!isPending && !isFinalized) revert RequestNotFound();
 
             _cancelWithdrawRequest(requests[i]);
             invalidatedRequestIds[i] = requestId;
@@ -376,7 +420,7 @@ contract PriorityWithdrawalQueue is
 
         if (beforeEEthShares - eEthSharesMoved != eETH.shares(address(this))) revert InvalidEEthSharesAfterRemainderHandling();
 
-        emit RemainderHandled(uint96(eEthAmountToTreasury), uint96(liquidityPool.amountForShare(eEthSharesToBurn)));
+        emit RemainderHandled(uint96(eEthAmountToTreasury), uint96(eEthSharesToBurn));
     }
 
     /// @notice Update the share remainder split to treasury
@@ -492,7 +536,8 @@ contract PriorityWithdrawalQueue is
             amountOfEEth: amountOfEEth,
             shareOfEEth: shareOfEEth,
             nonce: requestNonce,
-            creationTime: timeNow
+            creationTime: timeNow,
+            amountLocked: 0 // Set to 0 for pending requests
         });
 
         requestId = keccak256(abi.encode(req));
@@ -510,21 +555,17 @@ contract PriorityWithdrawalQueue is
         );
     }
 
-    function _dequeueWithdrawRequest(WithdrawRequest calldata request) internal returns (bytes32 requestId) {
-        requestId = keccak256(abi.encode(request));
-        bool removedFromSet = _withdrawRequests.remove(requestId);
-        if (!removedFromSet) revert RequestNotFound();
-
-        _finalizedRequests.remove(requestId);
-    }
-
     function _cancelWithdrawRequest(WithdrawRequest calldata request) internal returns (bytes32 requestId) {
         requestId = keccak256(abi.encode(request));
 
-        // Check if finalized BEFORE dequeue (dequeue removes from finalized set)
-        bool wasFinalized = _finalizedRequests.contains(requestId);
+        // Check if this is a finalized request (amountLocked > 0) or pending request (amountLocked = 0)
+        bool isFinalized = request.amountLocked > 0;
 
-        _dequeueWithdrawRequest(request);
+        if (isFinalized) {
+            if (!_finalizedRequests.remove(requestId)) revert RequestNotFound();
+        } else {
+            if (!_withdrawRequests.remove(requestId)) revert RequestNotFound();
+        }
 
         // Calculate current value of shares
         uint256 amountForShares = liquidityPool.amountForShare(request.shareOfEEth);
@@ -542,8 +583,9 @@ contract PriorityWithdrawalQueue is
             : 0;
         totalRemainderShares += uint96(remainder);
 
-        if (wasFinalized) {
-            liquidityPool.reduceEthAmountLockedForPriorityWithdrawal(uint128(amountToReturn));
+        if (isFinalized) {
+            // Use the amountLocked from the request struct
+            liquidityPool.reduceEthAmountLockedForPriorityWithdrawal(request.amountLocked);
         }
 
         IERC20(address(eETH)).safeTransfer(request.user, amountToReturn);
@@ -554,19 +596,18 @@ contract PriorityWithdrawalQueue is
     function _claimWithdraw(WithdrawRequest calldata request) internal {
         if (request.user != msg.sender) revert NotRequestOwner();
 
+        // Finalized requests must have amountLocked > 0
+        if (request.amountLocked == 0) revert RequestNotFinalized();
+        
         bytes32 requestId = keccak256(abi.encode(request));
 
-        if (!_withdrawRequests.contains(requestId)) revert RequestNotFound();
+        // Finalized requests are only in _finalizedRequests (removed from _withdrawRequests during fulfillment)
         if (!_finalizedRequests.contains(requestId)) revert RequestNotFinalized();
 
-        uint256 amountForShares = liquidityPool.amountForShare(request.shareOfEEth);
-        uint256 amountToWithdraw = request.amountOfEEth < amountForShares 
-            ? request.amountOfEEth 
-            : amountForShares;
+        uint256 amountToWithdraw = request.amountLocked;
 
         uint256 sharesToBurn = liquidityPool.sharesForWithdrawalAmount(amountToWithdraw);
 
-        _withdrawRequests.remove(requestId);
         _finalizedRequests.remove(requestId);
 
         // Track remainder (difference between original shares and burned shares)
@@ -595,20 +636,23 @@ contract PriorityWithdrawalQueue is
     /// @param _shareOfEEth The share of eETH
     /// @param _nonce The request nonce
     /// @param _creationTime The creation timestamp
+    /// @param _amountLocked The amount locked (0 for pending, >0 for finalized)
     /// @return requestId The keccak256 hash of the request
     function generateWithdrawRequestId(
         address _user,
         uint96 _amountOfEEth,
         uint96 _shareOfEEth,
         uint32 _nonce,
-        uint32 _creationTime
+        uint32 _creationTime,
+        uint96 _amountLocked
     ) public pure returns (bytes32 requestId) {
         WithdrawRequest memory req = WithdrawRequest({
             user: _user,
             amountOfEEth: _amountOfEEth,
             shareOfEEth: _shareOfEEth,
             nonce: _nonce,
-            creationTime: _creationTime
+            creationTime: _creationTime,
+            amountLocked: _amountLocked
         });
         requestId = keccak256(abi.encode(req));
     }
@@ -617,13 +661,7 @@ contract PriorityWithdrawalQueue is
     /// @param request The withdrawal request
     /// @return requestId The keccak256 hash of the request
     function getRequestId(WithdrawRequest calldata request) external pure returns (bytes32) {
-        return generateWithdrawRequestId(
-            request.user,
-            request.amountOfEEth,
-            request.shareOfEEth,
-            request.nonce,
-            request.creationTime
-        );
+        return keccak256(abi.encode(request));
     }
 
     /// @notice Get all active request IDs
@@ -654,13 +692,12 @@ contract PriorityWithdrawalQueue is
 
     /// @notice Get the claimable amount for a request
     /// @param request The withdrawal request
-    /// @return The claimable ETH amount
+    /// @return The claimable ETH amount (locked at fulfillment time)
     function getClaimableAmount(WithdrawRequest calldata request) external view returns (uint256) {
         bytes32 requestId = keccak256(abi.encode(request));
         if (!_finalizedRequests.contains(requestId)) revert RequestNotFinalized();
 
-        uint256 amountForShares = liquidityPool.amountForShare(request.shareOfEEth);
-        return request.amountOfEEth < amountForShares ? request.amountOfEEth : amountForShares;
+        return request.amountLocked;
     }
 
     /// @notice Get the total number of active requests

src/interfaces/IPriorityWithdrawalQueue.sol

@@ -8,12 +8,14 @@ interface IPriorityWithdrawalQueue {
     /// @param shareOfEEth eETH shares at time of request
     /// @param nonce Unique nonce to prevent hash collisions
     /// @param creationTime Timestamp when request was created
+    /// @param amountLocked ETH amount locked at fulfillment
     struct WithdrawRequest {
         address user;           // 20 bytes
         uint96 amountOfEEth;    // 12 bytes | Slot 1 = 32 bytes
         uint96 shareOfEEth;     // 12 bytes
         uint32 nonce;           // 4 bytes
-        uint32 creationTime;    // 4 bytes  | Slot 2 = 20 bytes
+        uint32 creationTime;    // 4 bytes
+        uint96 amountLocked;    // 12 bytes | Slot 2 = 32 bytes
     }
 
     struct PermitInput {