Validator consolidation

contracts/contracts/strategies/NativeStaking/CompoundingValidatorManager.sol

@@ -205,10 +205,15 @@ abstract contract CompoundingValidatorManager is Governable, Pausable {
 
     /// @dev Throws if called by any account other than the Registrator
     modifier onlyRegistrator() {
-        require(msg.sender == validatorRegistrator, "Not Registrator");
+        _onlyRegistrator();
         _;
     }
 
+    /// @dev internal function used to reduce contract size
+    function _onlyRegistrator() internal view {
+        require(msg.sender == validatorRegistrator, "Not Registrator");
+    }
+
     /// @dev Throws if called by any account other than the Registrator or Governor
     modifier onlyRegistratorOrGovernor() {
         require(
@@ -1013,7 +1018,7 @@ abstract contract CompoundingValidatorManager is Governable, Pausable {
     function verifyBalances(
         BalanceProofs calldata balanceProofs,
         PendingDepositProofs calldata pendingDepositProofs
-    ) external {
+    ) external onlyRegistrator {
         // Load previously snapped balances for the given block root
         Balances memory balancesMem = snappedBalance;
         // Check the balances are the latest

contracts/contracts/strategies/NativeStaking/ValidatorRegistrator.sol

@@ -7,6 +7,7 @@ import { IDepositContract } from "../../interfaces/IDepositContract.sol";
 import { IVault } from "../../interfaces/IVault.sol";
 import { IWETH9 } from "../../interfaces/IWETH9.sol";
 import { ISSVNetwork, Cluster } from "../../interfaces/ISSVNetwork.sol";
+import { BeaconConsolidation } from "../../beacon/BeaconConsolidation.sol";
 
 struct ValidatorStakeData {
     bytes pubkey;
@@ -80,6 +81,19 @@ abstract contract ValidatorRegistrator is Governable, Pausable {
         bytes pubKey,
         uint64[] operatorIds
     );
+    event ConsolidationRequested(
+        bytes[] sourcePubKeys,
+        bytes targetPubKey,
+        uint256 consolidationCount
+    );
+    event ConsolidationFailed(
+        bytes[] sourcePubKeys,
+        uint256 consolidationCount
+    );
+    event ConsolidationConfirmed(
+        uint256 consolidationCount,
+        uint256 activeDepositedValidators
+    );
     event StakeETHThresholdChanged(uint256 amount);
     event StakeETHTallyReset();
 
@@ -360,6 +374,103 @@ abstract contract ValidatorRegistrator is Governable, Pausable {
         ISSVNetwork(SSV_NETWORK).withdraw(operatorIds, ssvAmount, cluster);
     }
 
+    /***************************************
+            Consolidation functions
+    ****************************************/
+
+    /**
+     * @notice Initiates the consolidation of multiple source sweeping validators to a single compounding validator.
+     * @dev The validator registrator should be set to the ConsolidationController contract which
+     * has checks against the target validator.
+     * @param sourcePubKeys The full public keys of the source validators to be consolidated.
+     * @param targetPubKey The full public key of the target validator to consolidate into.
+     */
+    function requestConsolidation(
+        bytes[] calldata sourcePubKeys,
+        bytes calldata targetPubKey
+    ) external payable nonReentrant whenNotPaused onlyRegistrator {
+        // Hash using the Native Staking Strategy's hashing method.
+        // This is different to the Beacon chain's method.
+        bytes32 targetPubKeyHash = keccak256(targetPubKey);
+        bytes32 sourcePubKeyHash;
+
+        // For each source validator
+        for (uint256 i = 0; i < sourcePubKeys.length; ++i) {
+            sourcePubKeyHash = keccak256(sourcePubKeys[i]);
+            require(sourcePubKeys[i].length == 48, "Invalid source public key");
+            require(sourcePubKeyHash != targetPubKeyHash, "Self consolidation");
+            require(
+                validatorsStates[sourcePubKeyHash] == VALIDATOR_STATE.STAKED,
+                "Source validator not staked"
+            );
+
+            // Store the state of the source validator as exiting so it can be removed
+            // after the consolidation is confirmed
+            validatorsStates[sourcePubKeyHash] = VALIDATOR_STATE.EXITING;
+
+            // Request consolidation from source to target validator
+            BeaconConsolidation.request(sourcePubKeys[i], targetPubKey);
+        }
+
+        emit ConsolidationRequested(
+            sourcePubKeys,
+            targetPubKey,
+            sourcePubKeys.length
+        );
+    }
+
+    /**
+     * @notice A consolidation request can fail to be processed on the beacon chain
+     * for various reasons. For example, the pending consolidation queue is full with 262,144 requests.
+     * This restores the validator states back to STAKED so they can be consolidated again or exited.
+     * @param sourcePubKeys The full public keys of the source validators that failed to be consolidated.
+     */
+    function failConsolidation(bytes[] calldata sourcePubKeys)
+        external
+        nonReentrant
+        whenNotPaused
+        onlyRegistrator
+    {
+        bytes32 sourcePubKeyHash;
+
+        // For each failed source validator
+        for (uint256 i = 0; i < sourcePubKeys.length; ++i) {
+            require(sourcePubKeys[i].length == 48, "Invalid source public key");
+            sourcePubKeyHash = keccak256(sourcePubKeys[i]);
+            require(
+                validatorsStates[sourcePubKeyHash] == VALIDATOR_STATE.EXITING,
+                "Source validator not exiting"
+            );
+
+            // Store the state of the source validator back to staked
+            validatorsStates[sourcePubKeyHash] = VALIDATOR_STATE.STAKED;
+        }
+
+        emit ConsolidationFailed(sourcePubKeys, sourcePubKeys.length);
+    }
+
+    /**
+     * @notice Confirms that a consolidation has completed successfully on the beacon chain.
+     * This reduces the number of active deposited validators managed by this strategy which
+     * reduces the strategy's balance.
+     * @param consolidationCount The number of source validators that were consolidated.
+     */
+    function confirmConsolidation(uint256 consolidationCount)
+        external
+        nonReentrant
+        whenNotPaused
+        onlyRegistrator
+    {
+        // Store the reduced number of active deposited validators
+        // managed by this strategy
+        activeDepositedValidators -= consolidationCount;
+
+        emit ConsolidationConfirmed(
+            consolidationCount,
+            activeDepositedValidators
+        );
+    }
+
     /***************************************
                  Abstract
     ****************************************/

contracts/deploy/hoodi/033_validator_consolidation.js

@@ -0,0 +1,68 @@
+const {
+  upgradeCompoundingStakingSSVStrategy,
+  upgradeNativeStakingSSVStrategy,
+} = require("../deployActions");
+const { deployWithConfirmation } = require("../../utils/deploy");
+const { getDefenderSigner, getSigner } = require("../../utils/signers");
+const { isFork } = require("../../test/helpers.js");
+const { resolveContract } = require("../../utils/resolvers");
+
+const mainExport = async () => {
+  const sDeployer = isFork ? await getSigner() : await getDefenderSigner();
+  const deployerAddress = await sDeployer.getAddress();
+
+  // 1. Upgrade the Native Staking Strategy
+  await upgradeNativeStakingSSVStrategy();
+
+  const nativeStakingStrategy = await resolveContract(
+    "NativeStakingSSVStrategyProxy",
+    "NativeStakingSSVStrategy"
+  );
+
+  // 2. Upgrade the Compounding Staking Strategy
+  await upgradeCompoundingStakingSSVStrategy();
+
+  const compoundingStakingStrategy = await resolveContract(
+    "CompoundingStakingSSVStrategyProxy",
+    "CompoundingStakingSSVStrategy"
+  );
+
+  // 3. Deploy the new Consolidation Controller
+  console.log(`Deploy ConsolidationController`);
+  const dConsolidationController = await deployWithConfirmation(
+    "ConsolidationController",
+    [
+      deployerAddress, // Owner
+      deployerAddress, // Validator Registrator
+      nativeStakingStrategy.address, // Old Native Staking Strategy 2
+      nativeStakingStrategy.address, // Old Native Staking Strategy 3
+      compoundingStakingStrategy.address, // New Compounding Staking Strategy
+    ]
+  );
+
+  // 4. Set the Registrator of the Compounding Staking Strategy to the Consolidation Controller
+  console.log(
+    `About to set Registrator of CompoundingStakingSSVStrategy to ConsolidationController`
+  );
+  await compoundingStakingStrategy
+    .connect(sDeployer)
+    .setRegistrator(dConsolidationController.address);
+
+  // 5. Set the Registrator of the Native Staking Strategy to the Consolidation Controller
+  console.log(
+    `About to set Registrator of NativeStakingSSVStrategy to ConsolidationController`
+  );
+  await nativeStakingStrategy
+    .connect(sDeployer)
+    .setRegistrator(dConsolidationController.address);
+
+  console.log("Running 033 deployment done");
+  return true;
+};
+
+mainExport.id = "033_validator_consolidation";
+mainExport.tags = [];
+mainExport.dependencies = [];
+mainExport.skip = () => false;
+
+module.exports = mainExport;

contracts/deploy/mainnet/169_staking_consolidation.js

@@ -0,0 +1,154 @@
+const { deploymentWithGovernanceProposal } = require("../../utils/deploy");
+const { beaconChainGenesisTimeMainnet } = require("../../utils/constants");
+const addresses = require("../../utils/addresses");
+
+module.exports = deploymentWithGovernanceProposal(
+  {
+    deployName: "169_staking_consolidation",
+    forceDeploy: false,
+    //forceSkip: true,
+    reduceQueueTime: true,
+    deployerIsProposer: false,
+    // proposalId: "",
+  },
+  async ({ deployWithConfirmation, ethers }) => {
+    // Current contracts
+    const cOETHVaultProxy = await ethers.getContract("OETHVaultProxy");
+
+    const cCompoundingStakingStrategyProxy = await ethers.getContract(
+      "CompoundingStakingSSVStrategyProxy"
+    );
+    const cCompoundingStakingSSVStrategy = await ethers.getContractAt(
+      "CompoundingStakingSSVStrategy",
+      cCompoundingStakingStrategyProxy.address
+    );
+    const cBeaconProofs = await ethers.getContract("BeaconProofs");
+
+    const cNativeStakingStrategy2Proxy = await ethers.getContract(
+      "NativeStakingSSVStrategy2Proxy"
+    );
+    const cNativeStakingFeeAccumulator2Proxy = await ethers.getContract(
+      "NativeStakingFeeAccumulator2Proxy"
+    );
+    const cNativeStakingStrategy2 = await ethers.getContractAt(
+      "NativeStakingSSVStrategy",
+      cNativeStakingStrategy2Proxy.address
+    );
+    const cNativeStakingStrategy3Proxy = await ethers.getContract(
+      "NativeStakingSSVStrategy3Proxy"
+    );
+    const cNativeStakingFeeAccumulator3Proxy = await ethers.getContract(
+      "NativeStakingFeeAccumulator3Proxy"
+    );
+    const cNativeStakingStrategy3 = await ethers.getContractAt(
+      "NativeStakingSSVStrategy",
+      cNativeStakingStrategy3Proxy.address
+    );
+
+    // Deployer Actions
+    // ----------------
+
+    // 1. Deploy the new Compounding Staking Strategy contracts
+
+    console.log("Deploy CompoundingStakingSSVStrategy");
+    const dCompoundingStakingStrategy = await deployWithConfirmation(
+      "CompoundingStakingSSVStrategy",
+      [
+        [addresses.zero, cOETHVaultProxy.address], //_baseConfig
+        addresses.mainnet.WETH, // wethAddress
+        addresses.mainnet.SSV, // ssvToken
+        addresses.mainnet.SSVNetwork, // ssvNetwork
+        addresses.mainnet.beaconChainDepositContract, // depositContractMock
+        cBeaconProofs.address, // BeaconProofs
+        beaconChainGenesisTimeMainnet,
+      ]
+    );
+
+    // 2. Deploy the new Native Staking Strategy implementations
+
+    console.log(`About to deploy NativeStakingSSVStrategy implementations`);
+    const dNativeStakingStrategy2Impl = await deployWithConfirmation(
+      "NativeStakingSSVStrategy",
+      [
+        [addresses.zero, cOETHVaultProxy.address], //_baseConfig
+        addresses.mainnet.WETH, // wethAddress
+        addresses.mainnet.SSV, // ssvToken
+        addresses.mainnet.SSVNetwork, // ssvNetwork
+        500, // maxValidators
+        cNativeStakingFeeAccumulator2Proxy.address, // feeAccumulator
+        addresses.mainnet.beaconChainDepositContract, // beacon chain deposit contract
+      ]
+    );
+    const dNativeStakingStrategy3Impl = await deployWithConfirmation(
+      "NativeStakingSSVStrategy",
+      [
+        [addresses.zero, cOETHVaultProxy.address], //_baseConfig
+        addresses.mainnet.WETH, // wethAddress
+        addresses.mainnet.SSV, // ssvToken
+        addresses.mainnet.SSVNetwork, // ssvNetwork
+        500, // maxValidators
+        cNativeStakingFeeAccumulator3Proxy.address, // feeAccumulator
+        addresses.mainnet.beaconChainDepositContract, // beacon chain deposit contract
+      ]
+    );
+
+    // 3. Deploy the new Consolidation Controller
+    console.log(`Deploy ConsolidationController`);
+    const dConsolidationController = await deployWithConfirmation(
+      "ConsolidationController",
+      [
+        addresses.mainnet.Guardian, // Admin 5/8 multisig
+        addresses.mainnet.validatorRegistrator, // Defender Relayer
+        cNativeStakingStrategy2.address, // Old Native Staking Strategy 2
+        cNativeStakingStrategy3.address, // Old Native Staking Strategy 3
+        cCompoundingStakingSSVStrategy.address, // New Compounding Staking Strategy
+      ]
+    );
+
+    console.log(`Finished deploying contracts`);
+
+    // Governance Actions
+    // ----------------
+    return {
+      name: `Update old Native Staking Strategies and new Compounding Staking Strategy`,
+      actions: [
+        // 1. Upgrade Compounding Staking Strategy
+        {
+          contract: cCompoundingStakingStrategyProxy,
+          signature: "upgradeTo(address)",
+          args: [dCompoundingStakingStrategy.address],
+        },
+        // 2. Upgrade Native Staking Strategy 2
+        {
+          contract: cNativeStakingStrategy2Proxy,
+          signature: "upgradeTo(address)",
+          args: [dNativeStakingStrategy2Impl.address],
+        },
+        // 3. Upgrade Native Staking Strategy 3
+        {
+          contract: cNativeStakingStrategy3Proxy,
+          signature: "upgradeTo(address)",
+          args: [dNativeStakingStrategy3Impl.address],
+        },
+        // 4. Set the Registrator of the Compounding Staking Strategy to the Consolidation Controller
+        {
+          contract: cCompoundingStakingSSVStrategy,
+          signature: "setRegistrator(address)",
+          args: [dConsolidationController.address],
+        },
+        // 5. Set the Registrator of the Native Staking Strategy 2 to the Consolidation Controller
+        {
+          contract: cNativeStakingStrategy2,
+          signature: "setRegistrator(address)",
+          args: [dConsolidationController.address],
+        },
+        // 6. Set the Registrator of the Native Staking Strategy 3 to the Consolidation Controller
+        {
+          contract: cNativeStakingStrategy3,
+          signature: "setRegistrator(address)",
+          args: [dConsolidationController.address],
+        },
+      ],
+    };
+  }
+);