remove validator tests added

Author: venimir-ssv

test/common/errors.ts

@@ -3,10 +3,12 @@ export const Errors = {
   INVALID_PUBLIC_KEYS_LENGTH: "InvalidPublicKeyLength",
   PUBLIC_KEYS_SHARES_LENGTH_MISMATCH: "PublicKeysSharesLengthMismatch",
   VALIDATOR_ALREADY_EXISTS_WITH_DATA: "ValidatorAlreadyExistsWithData",
+  VALIDATOR_DOES_NOT_EXIST: "ValidatorDoesNotExist",
   INVALID_OPERATOR_IDS_LENGTH: "InvalidOperatorIdsLength",
   UNSORTED_OPERATORS_LIST: "UnsortedOperatorsList",
   OPERATORS_LIST_NOT_UNIQUE: "OperatorsListNotUnique",
   CLUSTER_IS_LIQUIDATED: "ClusterIsLiquidated",
+  CLUSTER_DOES_NOT_EXISTS: "ClusterDoesNotExists",
   INCORRECT_CLUSTER_VERSION: "IncorrectClusterVersion",
   INCORRECT_CLUSTER_STATE: "IncorrectClusterState",
   CALLER_NOT_WHITELISTED: "CallerNotWhitelistedWithData",

test/common/events.ts

@@ -1,5 +1,6 @@
 export const Events = {
   VALIDATOR_ADDED: "ValidatorAdded",
+  VALIDATOR_REMOVED: "ValidatorRemoved",
   OPERATOR_ADDED: "OperatorAdded",
   OPERATOR_PRIVACY_STATUS_UPDATED: "OperatorPrivacyStatusUpdated",
   OPERATOR_REMOVED: "OperatorRemoved",

test/unit/SSVClusters/removeValidator.test.ts

@@ -0,0 +1,177 @@
+import { expect } from "chai";
+import type { NetworkConnection } from "hardhat/types/network";
+import type { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/types";
+import { getTestConnection } from "../../setup/connection.ts";
+import { ssvClustersHarnessFixture } from "../../setup/fixtures.ts";
+import type { NetworkHelpersType } from "../../common/types.ts";
+import { makePublicKey } from "../../common/helpers.ts";
+import { DEFAULT_ETH_REGISTER_VALUE, DEFAULT_SHARES, EMPTY_CLUSTER } from "../../common/constants.ts";
+import { Events } from "../../common/events.ts";
+import { Errors } from "../../common/errors.ts";
+
+type ClusterType = typeof EMPTY_CLUSTER;
+
+const createCluster = (overrides: Partial<ClusterType> = {}): ClusterType => ({
+  ...EMPTY_CLUSTER,
+  active: true,
+  ...overrides,
+});
+
+const parseClusterFromEvent = (contract: any, receipt: any, eventName: string): ClusterType => {
+  for (const log of receipt.logs ?? []) {
+    let parsed;
+    try {
+      parsed = contract.interface.parseLog(log);
+    } catch {
+      continue;
+    }
+
+    if (parsed?.name === eventName) {
+      const clusterTuple = parsed.args[parsed.args.length - 1];
+      const [validatorCount, networkFeeIndex, index, active, balance] = clusterTuple;
+
+      return {
+        validatorCount: BigInt(validatorCount),
+        networkFeeIndex: BigInt(networkFeeIndex),
+        index: BigInt(index),
+        active,
+        balance: BigInt(balance),
+      };
+    }
+  }
+
+  throw new Error(`Event ${eventName} not found`);
+};
+
+describe("SSVClusters function `removeValidator()`", async () => {
+  let connection: NetworkConnection<"generic">;
+  let networkHelpers: NetworkHelpersType;
+
+  let clusterOwner: HardhatEthersSigner;
+
+  before(async function () {
+    ({ connection, networkHelpers } = await getTestConnection());
+
+    [clusterOwner] = await connection.ethers.getSigners();
+  });
+
+  const deploySSVClustersAndPrepareOperatorsFixture = async () => {
+    return ssvClustersHarnessFixture(connection);
+  };
+
+  it("Removes an existing validator, updates cluster state and emits correct events", async function () {
+    const { clusters, operatorIds } =
+      await networkHelpers.loadFixture(deploySSVClustersAndPrepareOperatorsFixture);
+
+    const publicKey = makePublicKey(1);
+
+    const registerTx = await clusters.registerValidator(
+      publicKey,
+      operatorIds,
+      DEFAULT_SHARES,
+      0,
+      createCluster(),
+      { value: DEFAULT_ETH_REGISTER_VALUE }
+    );
+    const registerReceipt = await registerTx.wait();
+    const clusterAfterRegister = parseClusterFromEvent(clusters, registerReceipt, Events.VALIDATOR_ADDED);
+
+    const removeTx = await clusters.removeValidator(publicKey, operatorIds, clusterAfterRegister);
+    const removeReceipt = await removeTx.wait();
+    const clusterAfterRemove = parseClusterFromEvent(clusters, removeReceipt, Events.VALIDATOR_REMOVED);
+
+    await expect(removeTx).to.emit(clusters, Events.VALIDATOR_REMOVED);
+    expect(clusterAfterRemove.validatorCount).to.equal(0n);
+    expect(clusterAfterRemove.active).to.equal(true);
+  });
+
+  it("Is reverted with 'ValidatorDoesNotExist' when validator was not registered", async function () {
+    const { clusters, operatorIds } =
+      await networkHelpers.loadFixture(deploySSVClustersAndPrepareOperatorsFixture);
+
+    const registeredKey = makePublicKey(1);
+    const registerTx = await clusters.registerValidator(
+      registeredKey,
+      operatorIds,
+      DEFAULT_SHARES,
+      0,
+      createCluster(),
+      { value: DEFAULT_ETH_REGISTER_VALUE }
+    );
+    const registerReceipt = await registerTx.wait();
+    const clusterAfterRegister = parseClusterFromEvent(clusters, registerReceipt, Events.VALIDATOR_ADDED);
+
+    const nonExistingKey = makePublicKey(2);
+    await expect(clusters.removeValidator(
+      nonExistingKey,
+      operatorIds,
+      clusterAfterRegister
+    )).to.be.revertedWithCustomError(clusters, Errors.VALIDATOR_DOES_NOT_EXIST);
+  });
+
+  it("Is reverted with 'IncorrectClusterState' when provided cluster data is stale or mismatched", async function () {
+    const { clusters, operatorIds } =
+      await networkHelpers.loadFixture(deploySSVClustersAndPrepareOperatorsFixture);
+
+    const publicKey = makePublicKey(1);
+    const registerTx = await clusters.registerValidator(
+      publicKey,
+      operatorIds,
+      DEFAULT_SHARES,
+      0,
+      createCluster(),
+      { value: DEFAULT_ETH_REGISTER_VALUE }
+    );
+    const registerReceipt = await registerTx.wait();
+    const clusterAfterRegister = parseClusterFromEvent(clusters, registerReceipt, Events.VALIDATOR_ADDED);
+
+    const mismatchedCluster = {
+      ...clusterAfterRegister,
+      balance: clusterAfterRegister.balance + 1n,
+    };
+
+    await expect(clusters.removeValidator(
+      publicKey,
+      operatorIds,
+      mismatchedCluster
+    )).to.be.revertedWithCustomError(clusters, Errors.INCORRECT_CLUSTER_STATE);
+  });
+
+  it("Is reverted with 'ClusterDoesNotExists' when attempting to remove from a missing cluster", async function () {
+    const { clusters, operatorIds } =
+      await networkHelpers.loadFixture(deploySSVClustersAndPrepareOperatorsFixture);
+
+    await expect(clusters.removeValidator(
+      makePublicKey(1),
+      operatorIds,
+      createCluster()
+    )).to.be.revertedWithCustomError(clusters, Errors.CLUSTER_DOES_NOT_EXISTS);
+  });
+
+  it("Is reverted with 'ValidatorDoesNotExist' when removing a validator twice", async function () {
+    const { clusters, operatorIds } =
+      await networkHelpers.loadFixture(deploySSVClustersAndPrepareOperatorsFixture);
+
+    const publicKey = makePublicKey(1);
+    const registerTx = await clusters.registerValidator(
+      publicKey,
+      operatorIds,
+      DEFAULT_SHARES,
+      0,
+      createCluster(),
+      { value: DEFAULT_ETH_REGISTER_VALUE }
+    );
+    const registerReceipt = await registerTx.wait();
+    const clusterAfterRegister = parseClusterFromEvent(clusters, registerReceipt, Events.VALIDATOR_ADDED);
+
+    const removeTx = await clusters.removeValidator(publicKey, operatorIds, clusterAfterRegister);
+    const removeReceipt = await removeTx.wait();
+    const clusterAfterRemove = parseClusterFromEvent(clusters, removeReceipt, Events.VALIDATOR_REMOVED);
+
+    await expect(clusters.removeValidator(
+      publicKey,
+      operatorIds,
+      clusterAfterRemove
+    )).to.be.revertedWithCustomError(clusters, Errors.VALIDATOR_DOES_NOT_EXIST);
+  });
+});