feat: deposit queue (CS-55)

src/interfaces/ICommunityStakingBondManager.sol

@@ -53,4 +53,6 @@ interface ICommunityStakingBondManager {
         uint256 nodeOperatorId,
         uint256 newKeysCount
     ) external view returns (uint256);
+
+    function penalize(uint256 nodeOperatorId, uint256 shares) external;
 }

src/lib/Batch.sol

@@ -0,0 +1,30 @@
+// SPDX-FileCopyrightText: 2023 Lido <[email protected]>
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity 0.8.21;
+
+/// @author madlabman
+library Batch {
+    /// @notice Serialize node operator id, batch start and count of keys into a single bytes32 value
+    function serialize(
+        uint128 nodeOperatorId,
+        uint64 start,
+        uint64 count
+    ) internal pure returns (bytes32 s) {
+        return bytes32(abi.encodePacked(nodeOperatorId, start, count));
+    }
+
+    /// @notice Deserialize node operator id, batch start and count of keys from a single bytes32 value
+    function deserialize(
+        bytes32 b
+    ) internal pure returns (uint128 nodeOperatorId, uint64 start, uint64 count) {
+        assembly {
+            nodeOperatorId := shr(128, b)
+            start := shr(64, b)
+            count := b
+        }
+    }
+
+    function isNil(bytes32 b) internal pure returns (bool) {
+        return b == bytes32(0);
+    }
+}

src/lib/QueueLib.sol

@@ -0,0 +1,56 @@
+// SPDX-FileCopyrightText: 2023 Lido <[email protected]>
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity 0.8.21;
+
+
+/// @author madlabman
+library QueueLib {
+    bytes32 public constant NULL_POINTER = bytes32(0);
+
+    struct Queue {
+        mapping(bytes32 => bytes32) queue;
+        bytes32 front;
+        bytes32 back;
+    }
+
+    function enqueue(Queue storage self, bytes32 item) internal {
+        require(item != NULL_POINTER, "Queue: item is zero");
+        require(self.queue[item] == NULL_POINTER, "Queue: item already enqueued");
+
+        if (self.front == self.queue[self.front]) {
+            self.queue[self.front] = item;
+        }
+
+        self.queue[self.back] = item;
+        self.back = item;
+    }
+
+    function dequeue(Queue storage self) internal notEmpty(self) returns (bytes32 item) {
+        item = self.queue[self.front];
+        self.front = item;
+    }
+
+    function peek(Queue storage self) internal view returns (bytes32) {
+        return self.queue[self.front];
+    }
+
+    function at(Queue storage self, bytes32 pointer) internal view returns (bytes32) {
+        return self.queue[pointer];
+    }
+
+    function remove(Queue storage self, bytes32 pointerToItem, bytes32 item) internal {
+        require(self.queue[pointerToItem] == item, "Queue: wrong pointer given");
+
+        self.queue[pointerToItem] = self.queue[item];
+        self.queue[item] = NULL_POINTER;
+
+        if (self.back == item) {
+            self.back = pointerToItem;
+        }
+    }
+
+    modifier notEmpty(Queue storage self) {
+        require(self.front != self.back, "Queue: empty");
+        _;
+    }
+}

test/Batch.t.sol

@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: 2023 Lido <[email protected]>
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity 0.8.21;
+
+import "forge-std/Test.sol";
+
+import { Batch } from "../src/lib/Batch.sol";
+
+contract BatchTest is Test {
+    function test_serialize() public {
+        bytes32 b = Batch.serialize({
+            nodeOperatorId: 999,
+            start: 3,
+            count: 42
+        });
+
+        assertEq(
+            b,
+            //            noIndex            |    start      |     count     |
+            0x000000000000000000000000000003e70000000000000003000000000000002a
+        );
+    }
+
+    function test_deserialize() public {
+        (uint128 nodeOperatorId, uint64 start, uint64 count) = Batch
+            .deserialize(
+                0x0000000000000000000000000000000000000000000000000000000000000000
+            );
+
+        assertEq(nodeOperatorId, 0, "nodeOperatorId != 0");
+        assertEq(start, 0, "start != 0");
+        assertEq(count, 0, "count != 0");
+
+        (nodeOperatorId, start, count) = Batch.deserialize(
+            0x000000000000000000000000000003e70000000000000003000000000000002a
+        );
+
+        assertEq(nodeOperatorId, 999, "nodeOperatorId != 999");
+        assertEq(start, 3, "start != 3");
+        assertEq(count, 42, "count != 42");
+
+        (nodeOperatorId, start, count) = Batch.deserialize(
+            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+        );
+
+        assertEq(
+            nodeOperatorId,
+            type(uint128).max,
+            "nodeOperatorId != uint128.max"
+        );
+        assertEq(start, type(uint64).max, "start != uint64.max");
+        assertEq(count, type(uint64).max, "count != uint64.max");
+    }
+}

test/CSMAddValidator.t.sol

@@ -202,6 +202,12 @@ contract CSMAddNodeOperator is
             keys,
             signatures
         );
+
+        {
+            // Pretend to be a key validation oracle
+            csm.setNodeOperatorStakingLimit(0, 1);
+        }
+
         (bytes memory obtainedKeys, bytes memory obtainedSignatures) = csm
             .obtainDepositData(1, "");
         assertEq(obtainedKeys, keys);

test/CSMInit.t.sol

@@ -56,6 +56,6 @@ contract CSMInitTest is Test, Fixtures {
 
     function test_SetBondManager() public {
         csm.setBondManager(address(bondManager));
-        assertEq(address(csm.bondManagerAddress()), address(bondManager));
+        assertEq(address(csm.bondManager()), address(bondManager));
     }
 }

test/QueueLib.t.sol

@@ -0,0 +1,89 @@
+// SPDX-FileCopyrightText: 2023 Lido <[email protected]>
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity 0.8.21;
+
+import "forge-std/Test.sol";
+import "forge-std/console.sol";
+
+import { QueueLib } from "../src/lib/QueueLib.sol";
+
+contract QueueLibTest is Test {
+    bytes32 p0 = keccak256("0x00"); // 0x27489e20a0060b723a1748bdff5e44570ee9fae64141728105692eac6031e8a4
+    bytes32 p1 = keccak256("0x01"); // 0xe127292c8f7eb20e1ae830ed6055b6eb36e261836100610d12677231d0791f7f
+    bytes32 p2 = keccak256("0x02"); // 0xd3974deccfd8aa6b77f0fcc2c0014e6e0574d32e56c1d75717d2667b529cd073
+
+    bytes32 nil = bytes32(0);
+    bytes32 buf;
+
+    using QueueLib for QueueLib.Queue;
+    QueueLib.Queue q;
+
+    function test_enqueue() public {
+        assertEq(q.peek(), nil);
+
+        q.enqueue(p0);
+        q.enqueue(p1);
+
+        assertEq(q.peek(), p0);
+        assertEq(q.at(p0), p1);
+    }
+
+    function test_dequeue() public {
+        {
+            vm.expectRevert("Queue: empty");
+            q.dequeue();
+        }
+
+        q.enqueue(p0);
+        q.enqueue(p1);
+        q.enqueue(p2);
+
+        buf = q.dequeue();
+        assertEq(buf, p0);
+        assertEq(q.peek(), p1);
+
+        buf = q.dequeue();
+        assertEq(buf, p1);
+        assertEq(q.peek(), p2);
+
+        q.dequeue();
+        assertEq(q.peek(), nil);
+
+        {
+            vm.expectRevert("Queue: empty");
+            q.dequeue();
+        }
+    }
+
+    function test_remove() public {
+        q.enqueue(p0);
+        q.enqueue(p1);
+        q.enqueue(p2);
+        // [+*p0, p1, p2]
+
+        q.remove(p0, p1);
+        // [+*p0, p2]
+
+        q.dequeue();
+        // [+p0, *p2]
+        buf = q.dequeue();
+        // [p0, +*p2]
+        assertEq(buf, p2);
+
+        q.enqueue(p1);
+        // [p0, +p2, *p1]
+        assertEq(q.peek(), p1);
+
+        q.remove(p2, p1);
+        // [p0, +*p2]
+        assertEq(q.peek(), nil);
+        {
+            vm.expectRevert("Queue: empty");
+            q.dequeue();
+        }
+
+        q.remove(p0, p2);
+        // [+*p0]
+        assertEq(q.peek(), nil);
+    }
+}

test/integration/StakingRouter.t.sol

@@ -101,18 +101,23 @@ contract StakingRouterIntegrationTest is Test, Utilities {
             _treasuryFee: 500
         });
         uint256[] memory ids = stakingRouter.getStakingModuleIds();
-        (bytes memory keys, bytes memory signatures) = keysSignatures(1);
+        (bytes memory keys, bytes memory signatures) = keysSignatures(2);
         address nodeOperator = address(2);
-        vm.deal(nodeOperator, 2 ether);
+        vm.deal(nodeOperator, 4 ether);
         vm.prank(nodeOperator);
-        csm.addNodeOperatorETH{ value: 2 ether }(
+        csm.addNodeOperatorETH{ value: 4 ether }(
             "test",
             nodeOperator,
-            1,
+            2,
             keys,
             signatures
         );
 
+        {
+            // Pretend to be a key validation oracle
+            csm.setNodeOperatorStakingLimit(0, 2);
+        }
+
         // It's impossible to process deposits if withdrawal requests amount is more than the buffered ether,
         // so we need to make sure that the buffered ether is enough by submitting this tremendous amount.
         address whale = nextAddress();