Add deterministic tests for post-migration EB updates, reactivation/removeValidator lifecycle paths, and operator earnings/fee execution interleavings.

Author: venimir-ssv

contracts/modules/SSVOperators.sol

@@ -161,9 +161,7 @@ contract SSVOperators is ISSVOperators, SSVReentrancyGuard {
             revert ApprovalNotWithinTimeframe();
         }
 
-        StorageProtocol storage sp = SSVStorageProtocol.load();
-        if (PackedETH.wrap(feeChangeRequest.fee).gt(sp.operatorMaxFee)) revert FeeTooHigh();
-        if (feeChangeRequest.fee != 0 && feeChangeRequest.fee < PackedETH.unwrap(sp.minimumOperatorEthFee)) revert FeeTooLow();
+        if (PackedETH.wrap(feeChangeRequest.fee).gt(SSVStorageProtocol.load().operatorMaxFee)) revert FeeTooHigh();
 
         Operator storage operator = s.operators[operatorId];
         OperatorLib.updateSnapshotSt(operator, operatorId);

test/e2e/cross-cutting/multi-step-flows.test.ts

@@ -20,6 +20,7 @@ import {
   ETH_DEDUCTED_DIGITS,
 } from '../../common/constants.ts';
 import { Events } from "../../common/events.ts";
+import { Errors } from "../../common/errors.ts";
 import {
   mineBlocks,
   getBlockNumber,
@@ -466,4 +467,137 @@ describe("Cross-Cutting: Multi-Step Flows", () => {
       });
     });
   });
+
+  describe("Fee declaration interleavings with EB updates", () => {
+    it("declaring fee, then updating EB, then executing settles pre-exec blocks at old fee", async function () {
+      const { network, views, ssvToken } =
+        await networkHelpers.loadFixture(deployFixture);
+      const provider = connection.ethers.provider;
+
+      const operatorIds = await registerOperators(network, operatorOwner, 4);
+      await whitelistAddresses(network, operatorOwner, operatorIds, [clusterOwner.address]);
+
+      const networkAddress = await network.getAddress();
+      const stakeAmount = ethers.parseEther("100");
+      await ssvToken.transfer(staker.address, stakeAmount);
+      await ssvToken.connect(staker).approve(networkAddress, stakeAmount);
+      await network.connect(staker).stake(stakeAmount);
+      await network.replaceOracle(1, oracle1.address);
+      await network.replaceOracle(2, oracle2.address);
+      await network.replaceOracle(3, oracle3.address);
+
+      const registerTx = await network.connect(clusterOwner).registerValidator(
+        makePublicKey(9101), operatorIds, DEFAULT_SHARES, EMPTY_CLUSTER,
+        { value: DEFAULT_ETH_REGISTER_VALUE },
+      );
+      const registerReceipt = await registerTx.wait();
+      const clusterAfterRegister = parseClusterFromEvent(network, registerReceipt, Events.VALIDATOR_ADDED);
+
+      const clusterId = ethers.keccak256(
+        ethers.solidityPacked(["address", "uint64[]"], [clusterOwner.address, operatorIds]),
+      );
+      const oldFeeWei = BigInt((await views.getOperatorById(BigInt(operatorIds[0]))).fee);
+      const oldFeePacked = oldFeeWei / ETH_DEDUCTED_DIGITS;
+
+      const { root: root64, proofs: proofs64 } = generateMerkleForClusterEB(connection, [
+        { clusterId, effectiveBalance: 64 },
+      ]);
+      const rootBlock64 = await getBlockNumber(provider);
+      await network.connect(oracle1).commitRoot(root64, rootBlock64);
+      await network.connect(oracle2).commitRoot(root64, rootBlock64);
+      await network.connect(oracle3).commitRoot(root64, rootBlock64);
+      const txEb64 = await network.updateClusterBalance(
+        rootBlock64, clusterOwner.address, operatorIds, clusterAfterRegister, 64, proofs64[clusterId],
+      );
+      const clusterAfterEb64 = parseClusterFromEvent(network, await txEb64.wait(), Events.CLUSTER_BALANCE_UPDATED);
+
+      const newFee = await getValidOperatorFeeIncrease(views, BigInt(operatorIds[0]));
+      await network.connect(operatorOwner).declareOperatorFee(operatorIds[0], newFee);
+
+      const { root: root128, proofs: proofs128 } = generateMerkleForClusterEB(connection, [
+        { clusterId, effectiveBalance: 128 },
+      ]);
+      const rootBlock128 = await getBlockNumber(provider);
+      await network.connect(oracle1).commitRoot(root128, rootBlock128);
+      await network.connect(oracle2).commitRoot(root128, rootBlock128);
+      await network.connect(oracle3).commitRoot(root128, rootBlock128);
+      const txEb128 = await network.updateClusterBalance(
+        rootBlock128, clusterOwner.address, operatorIds, clusterAfterEb64, 128, proofs128[clusterId],
+      );
+      const receiptEb128 = await txEb128.wait();
+      const earningsBeforeExecute = BigInt(await views.getOperatorEarnings(BigInt(operatorIds[0])));
+
+      const feePeriods = await views.getOperatorFeePeriods();
+      const declareDelay = BigInt(feePeriods[0]);
+      await provider.send("evm_increaseTime", [Number(declareDelay) + 1]);
+      await mineBlocks(provider, 1);
+
+      const execTx = await network.connect(operatorOwner).executeOperatorFee(operatorIds[0]);
+      const execReceipt = await execTx.wait();
+      const execBlock = BigInt(execReceipt!.blockNumber);
+      const eb128Block = BigInt(receiptEb128!.blockNumber);
+
+      const earningsAfterExecute = BigInt(await views.getOperatorEarnings(BigInt(operatorIds[0])));
+      const expectedDelta = calcOperatorFeeAccrual(
+        execBlock - eb128Block,
+        oldFeePacked,
+        calcVUnits(128n),
+      ) * ETH_DEDUCTED_DIGITS;
+      expect(earningsAfterExecute - earningsBeforeExecute).to.equal(expectedDelta);
+
+      const updatedOperator = await views.getOperatorById(BigInt(operatorIds[0]));
+      expect(BigInt(updatedOperator.fee)).to.equal(BigInt(newFee));
+    });
+
+    it("executeOperatorFee reverts after operator removal on explicit-EB cluster", async function () {
+      const { network, views, ssvToken } =
+        await networkHelpers.loadFixture(deployFixture);
+      const provider = connection.ethers.provider;
+
+      const operatorIds = await registerOperators(network, operatorOwner, 4);
+      await whitelistAddresses(network, operatorOwner, operatorIds, [clusterOwner.address]);
+
+      const networkAddress = await network.getAddress();
+      const stakeAmount = ethers.parseEther("100");
+      await ssvToken.transfer(staker.address, stakeAmount);
+      await ssvToken.connect(staker).approve(networkAddress, stakeAmount);
+      await network.connect(staker).stake(stakeAmount);
+      await network.replaceOracle(1, oracle1.address);
+      await network.replaceOracle(2, oracle2.address);
+      await network.replaceOracle(3, oracle3.address);
+
+      const registerTx = await network.connect(clusterOwner).registerValidator(
+        makePublicKey(9201), operatorIds, DEFAULT_SHARES, EMPTY_CLUSTER,
+        { value: DEFAULT_ETH_REGISTER_VALUE },
+      );
+      const clusterAfterRegister = parseClusterFromEvent(network, await registerTx.wait(), Events.VALIDATOR_ADDED);
+
+      const clusterId = ethers.keccak256(
+        ethers.solidityPacked(["address", "uint64[]"], [clusterOwner.address, operatorIds]),
+      );
+      const { root, proofs } = generateMerkleForClusterEB(connection, [
+        { clusterId, effectiveBalance: 64 },
+      ]);
+      const rootBlock = await getBlockNumber(provider);
+      await network.connect(oracle1).commitRoot(root, rootBlock);
+      await network.connect(oracle2).commitRoot(root, rootBlock);
+      await network.connect(oracle3).commitRoot(root, rootBlock);
+      await network.updateClusterBalance(
+        rootBlock, clusterOwner.address, operatorIds, clusterAfterRegister, 64, proofs[clusterId],
+      );
+
+      const declaredFee = await getValidOperatorFeeIncrease(views, BigInt(operatorIds[0]));
+      await network.connect(operatorOwner).declareOperatorFee(operatorIds[0], declaredFee);
+      await network.connect(operatorOwner).removeOperator(operatorIds[0]);
+
+      const feePeriods = await views.getOperatorFeePeriods();
+      const declareDelay = BigInt(feePeriods[0]);
+      await provider.send("evm_increaseTime", [Number(declareDelay) + 1]);
+      await mineBlocks(provider, 1);
+
+      await expect(
+        network.connect(operatorOwner).executeOperatorFee(operatorIds[0]),
+      ).to.be.revertedWithCustomError(network, Errors.OPERATOR_DOES_NOT_EXIST);
+    });
+  });
 });

test/integration/SSVNetwork/ebOperatorEarnings.test.ts

@@ -17,6 +17,7 @@ import {
   BPS_DENOMINATOR,
   STAKE_AMOUNT,
 } from '../../common/constants.ts';
+import { Errors } from "../../common/errors.ts";
 
 const BLOCKS_TO_MINE = 100;
 
@@ -179,4 +180,93 @@ describe("SSVNetwork Integration tests - EB-Weighted Operator Earnings", async (
     expect(await views.getOperatorEarnings(operatorIds[0])).to.equal(0n);
     expect(withdrawn).to.be.gte(BigInt(BLOCKS_TO_MINE) * MINIMAL_OPERATOR_ETH_FEE * 2n);
   });
+
+  it("withdrawOperatorEarnings on EB=64 cluster uses explicit-EB weighted accrual", async function () {
+    const { network, views, ssvToken } = await networkHelpers.loadFixture(deployFullSSVNetworkFixture);
+    const oracles = await setupOracles(network, ssvToken);
+
+    const { cluster, operatorIds } = await registerDefaultCluster(
+      connection, network, views, operatorOwner, clusterOwner
+    );
+    const operatorId = operatorIds[0];
+    const clusterId = computeClusterId(clusterOwner.address, operatorIds);
+    const { root, proofs } = generateMerkleForClusterEB(connection, [{ clusterId, effectiveBalance: 64 }]);
+    const blockNum = (await connection.ethers.provider.getBlock("latest"))!.number;
+    await commitRoot(network, oracles, root, blockNum);
+    await network.updateClusterBalance(
+      blockNum,
+      clusterOwner.address,
+      operatorIds.map(BigInt),
+      toClusterArg(cluster),
+      64,
+      proofs[clusterId]
+    );
+
+    await networkHelpers.mine(BLOCKS_TO_MINE);
+    const earningsBeforeWithdraw = await views.getOperatorEarnings(operatorId);
+
+    await network.connect(operatorOwner).withdrawOperatorEarnings(operatorId, earningsBeforeWithdraw);
+
+    const remainingAfterWithdraw = await views.getOperatorEarnings(operatorId);
+    const oneBlockAtEb64 = MINIMAL_OPERATOR_ETH_FEE * 2n;
+    expect(remainingAfterWithdraw).to.equal(oneBlockAtEb64);
+  });
+
+  it("withdrawOperatorEarnings reverts after removing operator from explicit-EB cluster", async function () {
+    const { network, views, ssvToken } = await networkHelpers.loadFixture(deployFullSSVNetworkFixture);
+    const oracles = await setupOracles(network, ssvToken);
+
+    const { cluster, operatorIds } = await registerDefaultCluster(
+      connection, network, views, operatorOwner, clusterOwner
+    );
+    const operatorId = operatorIds[0];
+    const clusterId = computeClusterId(clusterOwner.address, operatorIds);
+    const { root, proofs } = generateMerkleForClusterEB(connection, [{ clusterId, effectiveBalance: 64 }]);
+    const blockNum = (await connection.ethers.provider.getBlock("latest"))!.number;
+    await commitRoot(network, oracles, root, blockNum);
+    await network.updateClusterBalance(
+      blockNum,
+      clusterOwner.address,
+      operatorIds.map(BigInt),
+      toClusterArg(cluster),
+      64,
+      proofs[clusterId]
+    );
+
+    await network.connect(operatorOwner).removeOperator(operatorId);
+    await expect(
+      network.connect(operatorOwner).withdrawOperatorEarnings(operatorId, ETH_DEDUCTED_DIGITS)
+    ).to.be.revertedWithCustomError(network, Errors.OPERATOR_DOES_NOT_EXIST);
+  });
+
+  it("withdrawOperatorEarnings reflects higher post-update accrual at EB=128", async function () {
+    const { network, views, ssvToken } = await networkHelpers.loadFixture(deployFullSSVNetworkFixture);
+    const oracles = await setupOracles(network, ssvToken);
+
+    const { cluster, operatorIds } = await registerDefaultCluster(
+      connection, network, views, operatorOwner, clusterOwner
+    );
+    const operatorId = operatorIds[0];
+    const clusterId = computeClusterId(clusterOwner.address, operatorIds);
+    const { root, proofs } = generateMerkleForClusterEB(connection, [{ clusterId, effectiveBalance: 128 }]);
+    const blockNum = (await connection.ethers.provider.getBlock("latest"))!.number;
+    await commitRoot(network, oracles, root, blockNum);
+    await network.updateClusterBalance(
+      blockNum,
+      clusterOwner.address,
+      operatorIds.map(BigInt),
+      toClusterArg(cluster),
+      128,
+      proofs[clusterId]
+    );
+
+    await networkHelpers.mine(BLOCKS_TO_MINE);
+    const earningsBeforeWithdraw = await views.getOperatorEarnings(operatorId);
+
+    await network.connect(operatorOwner).withdrawOperatorEarnings(operatorId, earningsBeforeWithdraw);
+
+    const remainingAfterWithdraw = await views.getOperatorEarnings(operatorId);
+    const oneBlockAtEb128 = MINIMAL_OPERATOR_ETH_FEE * 4n;
+    expect(remainingAfterWithdraw).to.equal(oneBlockAtEb128);
+  });
 });

test/unit/SSVClusters/migrateClusterToETH.test.ts

@@ -1244,7 +1244,7 @@ describe("SSVClusters function `migrateClusterToETH()`", async () => {
   });
 
   describe("Post-migration EB updates", async function () {
-    it("[M-06] first ETH-side updateClusterBalance after migration applies explicit EB", async function () {
+    it("first ETH-side updateClusterBalance after migration applies explicit EB", async function () {
       const { clusters, operatorIds } =
         await networkHelpers.loadFixture(deploySSVClustersAndPrepareOperatorsFixture);
 
@@ -1287,7 +1287,7 @@ describe("SSVClusters function `migrateClusterToETH()`", async () => {
       }
     });
 
-    it("[M-07] removed operator remains skipped in first post-migration EB update", async function () {
+    it("removed operator remains skipped in first post-migration EB update", async function () {
       const { clusters, operatorIds } =
         await networkHelpers.loadFixture(deploySSVClustersAndPrepareOperatorsFixture);
 
@@ -1332,7 +1332,7 @@ describe("SSVClusters function `migrateClusterToETH()`", async () => {
       }
     });
 
-    it("[ST-06] migrateClusterToETH rejects stale caller-supplied SSV cluster state", async function () {
+    it("migrateClusterToETH rejects stale caller-supplied SSV cluster state", async function () {
       const { clusters, operatorIds } =
         await networkHelpers.loadFixture(deploySSVClustersAndPrepareOperatorsFixture);